AT&T 2.0.19 Code drop, stage 2
[aaf/authz.git] / cadi / core / src / main / java / org / onap / aaf / cadi / Hash.java
diff --git a/cadi/core/src/main/java/org/onap/aaf/cadi/Hash.java b/cadi/core/src/main/java/org/onap/aaf/cadi/Hash.java
new file mode 100644 (file)
index 0000000..6babb4c
--- /dev/null
@@ -0,0 +1,258 @@
+/**
+ * ============LICENSE_START====================================================
+ * org.onap.aaf
+ * ===========================================================================
+ * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
+ * ===========================================================================
+ * 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.
+ * ============LICENSE_END====================================================
+ *
+ */
+
+package org.onap.aaf.cadi;
+
+import java.nio.ByteBuffer;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public class Hash {
+       private static char hexDigit[] = "0123456789abcdef".toCharArray();
+       
+/////////////////////////////////
+// MD5
+/////////////////////////////////
+       /**
+        * Encrypt MD5 from Byte Array to Byte Array
+        * @param input
+        * @return
+        * @throws NoSuchAlgorithmException
+        */
+       public static byte[] hashMD5 (byte[] input) throws NoSuchAlgorithmException {
+               // Note: Protect against Multi-thread issues with new MessageDigest 
+               MessageDigest md = MessageDigest.getInstance("MD5");
+               md.update(input); 
+               return md.digest();
+       }
+
+       /**
+        * Encrypt MD5 from Byte Array to Byte Array
+        * @param input
+        * @return
+        * @throws NoSuchAlgorithmException
+        */
+       public static byte[] hashMD5 (byte[] input, int offset, int length) throws NoSuchAlgorithmException {
+               // Note: Protect against Multi-thread issues with new MessageDigest 
+               MessageDigest md = MessageDigest.getInstance("MD5");
+               md.update(input,offset,length); 
+               return md.digest();
+       }
+
+
+
+       /**
+        * Convenience Function: Encrypt MD5 from String to String Hex representation 
+        * 
+        * @param input
+        * @return
+        * @throws NoSuchAlgorithmException
+        */
+       public static String hashMD5asStringHex(String input) throws NoSuchAlgorithmException {
+               byte[] output = hashMD5(input.getBytes());
+               StringBuilder sb = new StringBuilder("0x");
+                for (byte b : output) {
+                   sb.append(hexDigit[(b >> 4) & 0x0f]);
+                   sb.append(hexDigit[b & 0x0f]);
+                }
+                return sb.toString();
+       }
+
+/////////////////////////////////
+// SHA256
+/////////////////////////////////
+       /**
+        * SHA256 Hashing
+        */
+       public static byte[] hashSHA256(byte[] input) throws NoSuchAlgorithmException {
+               // Note: Protect against Multi-thread issues with new MessageDigest 
+               MessageDigest md = MessageDigest.getInstance("SHA-256");
+               md.update(input); 
+               return md.digest();
+       }
+
+       /**
+        * SHA256 Hashing
+        */
+       public static byte[] hashSHA256(byte[] input, int offset, int length) throws NoSuchAlgorithmException {
+               // Note: Protect against Multi-thread issues with new MessageDigest 
+               MessageDigest md = MessageDigest.getInstance("SHA-256");
+               md.update(input,offset,length); 
+               return md.digest();
+       }
+       
+       /**
+        * Convenience Function: Hash from String to String Hex representation
+        * 
+        * @param input
+        * @return
+        * @throws NoSuchAlgorithmException
+        */
+       public static String hashSHA256asStringHex(String input) throws NoSuchAlgorithmException {
+               return toHex(hashSHA256(input.getBytes()));
+       }
+
+       /**
+        * Convenience Function: Hash from String to String Hex representation
+        * 
+        * @param input
+        * @return
+        * @throws NoSuchAlgorithmException
+        */
+       public static String hashSHA256asStringHex(String input, int salt) throws NoSuchAlgorithmException {
+               byte[] in = input.getBytes();
+               ByteBuffer bb = ByteBuffer.allocate(Integer.SIZE + in.length);
+               bb.putInt(salt);
+               bb.put(input.getBytes());
+               return toHex(Hash.hashSHA256(bb.array()));
+       }
+       
+       /**
+        * Compare two byte arrays for equivalency
+        * @param ba1
+        * @param ba2
+        * @return
+        */
+       public static boolean isEqual(byte ba1[], byte ba2[]) {
+               if(ba1.length!=ba2.length)return false;
+               for(int i = 0;i<ba1.length; ++i) {
+                       if(ba1[i]!=ba2[i])return false;
+               }
+               return true;
+       }
+
+       public static int compareTo(byte[] a, byte[] b) {
+               int end = Math.min(a.length, b.length);
+               int compare = 0;
+               for(int i=0;compare == 0 && i<end;++i) {
+                       compare = a[i]-b[i];
+               }
+               if(compare==0)compare=a.length-b.length;
+               return compare;
+       }
+
+       public static String toHexNo0x(byte[] ba) {
+               StringBuilder sb = new StringBuilder();
+                for (byte b : ba) {
+                   sb.append(hexDigit[(b >> 4) & 0x0f]);
+                   sb.append(hexDigit[b & 0x0f]);
+                }
+                return sb.toString();
+       }
+
+       public static String toHex(byte[] ba) {
+               StringBuilder sb = new StringBuilder("0x");
+                for (byte b : ba) {
+                   sb.append(hexDigit[(b >> 4) & 0x0f]);
+                   sb.append(hexDigit[b & 0x0f]);
+                }
+                return sb.toString();
+       }
+       
+       public static String toHex(byte[] ba, int start, int length) {
+               StringBuilder sb = new StringBuilder("0x");
+                for (int i=start;i<length;++i) {
+                   sb.append(hexDigit[(ba[i] >> 4) & 0x0f]);
+                   sb.append(hexDigit[ba[i] & 0x0f]);
+                }
+                return sb.toString();
+       }
+
+       
+       public static byte[] fromHex(String s)  throws CadiException{
+               if(!s.startsWith("0x")) {
+                       throw new CadiException("HexString must start with \"0x\"");
+               }
+               boolean high = true;
+               int c;
+               byte b;
+               byte[] ba = new byte[(s.length()-2)/2];
+               int idx;
+               for(int i=2;i<s.length();++i) {
+                       c = s.charAt(i);
+                       if(c>=0x30 && c<=0x39) {
+                               b=(byte)(c-0x30);
+                       } else if(c>=0x61 && c<=0x66) {
+                               b=(byte)(c-0x57);  // account for "A"
+                       } else if(c>=0x41 && c<=0x46) {
+                               b=(byte)(c-0x37);
+                       } else {
+                               throw new CadiException("Invalid char '" + c + "' in HexString");
+                       }
+                       idx = (i-2)/2;
+                       if(high) {
+                               ba[idx]=(byte)(b<<4);
+                               high = false;
+                       } else {
+                               ba[idx]|=b;
+                               high = true;
+                       }
+               }
+               return ba;
+       }
+
+       /**
+        * Does not expect to start with "0x"
+        * if Any Character doesn't match, it returns null;
+        * 
+        * @param s
+        * @return
+        */
+       public static byte[] fromHexNo0x(String s) {
+               int c;
+               byte b;
+               byte[] ba;
+               boolean high;
+               int start;
+               if(s.length()%2==0) {
+                       ba = new byte[s.length()/2];
+                       high=true;
+                       start=0;
+               } else {
+                       ba = new byte[(s.length()/2)+1];
+                       high = false;
+                       start=1;
+               }
+               int idx;
+               for(int i=start;i<s.length();++i) {
+                       c = s.charAt((i-start));
+                       if(c>=0x30 && c<=0x39) {
+                               b=(byte)(c-0x30);
+                       } else if(c>=0x61 && c<=0x66) {
+                               b=(byte)(c-0x57);  // account for "A"
+                       } else if(c>=0x41 && c<=0x46) {
+                               b=(byte)(c-0x37);
+                       } else {
+                               return null;
+                       }
+                       idx = i/2;
+                       if(high) {
+                               ba[idx]=(byte)(b<<4);
+                               high = false;
+                       } else {
+                               ba[idx]|=b;
+                               high = true;
+                       }
+               }
+               return ba;
+       }
+
+}