/*     */ package cn.com.esgcc.ai.matrix.sdk.util.encrypt;
/*     */ 
/*     */ import java.math.BigInteger;
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ public class Util
/*     */ {
/*     */   public static byte[] intToBytes(int num) {
/*  13 */     byte[] bytes = new byte[4];
/*  14 */     bytes[0] = (byte)(0xFF & num >> 0);
/*  15 */     bytes[1] = (byte)(0xFF & num >> 8);
/*  16 */     bytes[2] = (byte)(0xFF & num >> 16);
/*  17 */     bytes[3] = (byte)(0xFF & num >> 24);
/*  18 */     return bytes;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int byteToInt(byte[] bytes) {
/*  28 */     int num = 0;
/*     */     
/*  30 */     int temp = (0xFF & bytes[0]) << 0;
/*  31 */     num |= temp;
/*  32 */     temp = (0xFF & bytes[1]) << 8;
/*  33 */     num |= temp;
/*  34 */     temp = (0xFF & bytes[2]) << 16;
/*  35 */     num |= temp;
/*  36 */     temp = (0xFF & bytes[3]) << 24;
/*  37 */     num |= temp;
/*  38 */     return num;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] longToBytes(long num) {
/*  48 */     byte[] bytes = new byte[8];
/*  49 */     for (int i = 0; i < 8; i++) {
/*  50 */       bytes[i] = (byte)(int)(0xFFL & num >> i * 8);
/*     */     }
/*     */     
/*  53 */     return bytes;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] byteConvert32Bytes(BigInteger n) {
/*  63 */     byte[] tmpd = (byte[])null;
/*  64 */     if (n == null) {
/*  65 */       return null;
/*     */     }
/*     */     
/*  68 */     if ((n.toByteArray()).length == 33) {
/*  69 */       tmpd = new byte[32];
/*  70 */       System.arraycopy(n.toByteArray(), 1, tmpd, 0, 32);
/*  71 */     } else if ((n.toByteArray()).length == 32) {
/*  72 */       tmpd = n.toByteArray();
/*     */     } else {
/*  74 */       tmpd = new byte[32];
/*  75 */       for (int i = 0; i < 32 - (n.toByteArray()).length; i++) {
/*  76 */         tmpd[i] = 0;
/*     */       }
/*  78 */       System.arraycopy(n.toByteArray(), 0, tmpd, 32 - (n.toByteArray()).length, (n.toByteArray()).length);
/*     */     } 
/*  80 */     return tmpd;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static BigInteger byteConvertInteger(byte[] b) {
/*  90 */     if (b[0] < 0) {
/*  91 */       byte[] temp = new byte[b.length + 1];
/*  92 */       temp[0] = 0;
/*  93 */       System.arraycopy(b, 0, temp, 1, b.length);
/*  94 */       return new BigInteger(temp);
/*     */     } 
/*  96 */     return new BigInteger(b);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String getHexString(byte[] bytes) {
/* 106 */     return getHexString(bytes, true);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String getHexString(byte[] bytes, boolean upperCase) {
/* 117 */     String ret = "";
/* 118 */     for (int i = 0; i < bytes.length; i++) {
/* 119 */       ret = ret + Integer.toString((bytes[i] & 0xFF) + 256, 16).substring(1);
/*     */     }
/* 121 */     return upperCase ? ret.toUpperCase() : ret;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static void printHexString(byte[] bytes) {
/* 130 */     for (int i = 0; i < bytes.length; i++) {
/* 131 */       String hex = Integer.toHexString(bytes[i] & 0xFF);
/* 132 */       if (hex.length() == 1) {
/* 133 */         hex = '0' + hex;
/*     */       }
/* 135 */       System.out.print("0x" + hex.toUpperCase() + ",");
/*     */     } 
/* 137 */     System.out.println("");
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] hexStringToBytes(String hexString) {
/* 147 */     if (hexString == null || hexString.equals("")) {
/* 148 */       return null;
/*     */     }
/*     */     
/* 151 */     hexString = hexString.toUpperCase();
/* 152 */     int length = hexString.length() / 2;
/* 153 */     char[] hexChars = hexString.toCharArray();
/* 154 */     byte[] d = new byte[length];
/* 155 */     for (int i = 0; i < length; i++) {
/* 156 */       int pos = i * 2;
/* 157 */       d[i] = (byte)(charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
/*     */     } 
/* 159 */     return d;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte charToByte(char c) {
/* 169 */     return (byte)"0123456789ABCDEF".indexOf(c);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */   
/* 175 */   private static final char[] DIGITS_LOWER = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/* 181 */   private static final char[] DIGITS_UPPER = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static char[] encodeHex(byte[] data) {
/* 191 */     return encodeHex(data, true);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static char[] encodeHex(byte[] data, boolean toLowerCase) {
/* 202 */     return encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   protected static char[] encodeHex(byte[] data, char[] toDigits) {
/* 213 */     int l = data.length;
/* 214 */     char[] out = new char[l << 1];
/*     */     
/* 216 */     for (int i = 0, j = 0; i < l; i++) {
/* 217 */       out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
/* 218 */       out[j++] = toDigits[0xF & data[i]];
/*     */     } 
/* 220 */     return out;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String encodeHexString(byte[] data) {
/* 230 */     return encodeHexString(data, true);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String encodeHexString(byte[] data, boolean toLowerCase) {
/* 241 */     return encodeHexString(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   protected static String encodeHexString(byte[] data, char[] toDigits) {
/* 252 */     return new String(encodeHex(data, toDigits));
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] decodeHex(char[] data) {
/* 263 */     int len = data.length;
/*     */     
/* 265 */     if ((len & 0x1) != 0) {
/* 266 */       throw new RuntimeException("Odd number of characters.");
/*     */     }
/*     */     
/* 269 */     byte[] out = new byte[len >> 1];
/*     */ 
/*     */     
/* 272 */     for (int i = 0, j = 0; j < len; i++) {
/* 273 */       int f = toDigit(data[j], j) << 4;
/* 274 */       j++;
/* 275 */       f |= toDigit(data[j], j);
/* 276 */       j++;
/* 277 */       out[i] = (byte)(f & 0xFF);
/*     */     } 
/*     */     
/* 280 */     return out;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   protected static int toDigit(char ch, int index) {
/* 292 */     int digit = Character.digit(ch, 16);
/* 293 */     if (digit == -1) {
/* 294 */       throw new RuntimeException("Illegal hexadecimal character " + ch + " at index " + index);
/*     */     }
/*     */     
/* 297 */     return digit;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String StringToAsciiString(String content) {
/* 307 */     String result = "";
/* 308 */     int max = content.length();
/* 309 */     for (int i = 0; i < max; i++) {
/* 310 */       char c = content.charAt(i);
/* 311 */       String b = Integer.toHexString(c);
/* 312 */       result = result + b;
/*     */     } 
/* 314 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String hexStringToString(String hexString, int encodeType) {
/* 325 */     String result = "";
/* 326 */     int max = hexString.length() / encodeType;
/* 327 */     for (int i = 0; i < max; i++) {
/* 328 */       char c = (char)hexStringToAlgorism(hexString
/* 329 */           .substring(i * encodeType, (i + 1) * encodeType));
/* 330 */       result = result + c;
/*     */     } 
/* 332 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int hexStringToAlgorism(String hex) {
/* 342 */     hex = hex.toUpperCase();
/* 343 */     int max = hex.length();
/* 344 */     int result = 0;
/* 345 */     for (int i = max; i > 0; i--) {
/* 346 */       char c = hex.charAt(i - 1);
/* 347 */       int algorism = 0;
/* 348 */       if (c >= '0' && c <= '9') {
/* 349 */         algorism = c - 48;
/*     */       } else {
/* 351 */         algorism = c - 55;
/*     */       } 
/* 353 */       result = (int)(result + Math.pow(16.0D, (max - i)) * algorism);
/*     */     } 
/* 355 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String hexStringToBinary(String hex) {
/* 365 */     hex = hex.toUpperCase();
/* 366 */     String result = "";
/* 367 */     int max = hex.length();
/* 368 */     for (int i = 0; i < max; i++) {
/* 369 */       char c = hex.charAt(i);
/* 370 */       switch (c) {
/*     */         case '0':
/* 372 */           result = result + "0000";
/*     */           break;
/*     */         case '1':
/* 375 */           result = result + "0001";
/*     */           break;
/*     */         case '2':
/* 378 */           result = result + "0010";
/*     */           break;
/*     */         case '3':
/* 381 */           result = result + "0011";
/*     */           break;
/*     */         case '4':
/* 384 */           result = result + "0100";
/*     */           break;
/*     */         case '5':
/* 387 */           result = result + "0101";
/*     */           break;
/*     */         case '6':
/* 390 */           result = result + "0110";
/*     */           break;
/*     */         case '7':
/* 393 */           result = result + "0111";
/*     */           break;
/*     */         case '8':
/* 396 */           result = result + "1000";
/*     */           break;
/*     */         case '9':
/* 399 */           result = result + "1001";
/*     */           break;
/*     */         case 'A':
/* 402 */           result = result + "1010";
/*     */           break;
/*     */         case 'B':
/* 405 */           result = result + "1011";
/*     */           break;
/*     */         case 'C':
/* 408 */           result = result + "1100";
/*     */           break;
/*     */         case 'D':
/* 411 */           result = result + "1101";
/*     */           break;
/*     */         case 'E':
/* 414 */           result = result + "1110";
/*     */           break;
/*     */         case 'F':
/* 417 */           result = result + "1111";
/*     */           break;
/*     */       } 
/*     */     } 
/* 421 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String AsciiStringToString(String content) {
/* 431 */     String result = "";
/* 432 */     int length = content.length() / 2;
/* 433 */     for (int i = 0; i < length; i++) {
/* 434 */       String c = content.substring(i * 2, i * 2 + 2);
/* 435 */       int a = hexStringToAlgorism(c);
/* 436 */       char b = (char)a;
/* 437 */       String d = String.valueOf(b);
/* 438 */       result = result + d;
/*     */     } 
/* 440 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String algorismToHexString(int algorism, int maxLength) {
/* 451 */     String result = "";
/* 452 */     result = Integer.toHexString(algorism);
/*     */     
/* 454 */     if (result.length() % 2 == 1) {
/* 455 */       result = "0" + result;
/*     */     }
/* 457 */     return patchHexString(result.toUpperCase(), maxLength);
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String byteToString(byte[] bytearray) {
/* 467 */     String result = "";
/*     */ 
/*     */     
/* 470 */     int length = bytearray.length;
/* 471 */     for (int i = 0; i < length; i++) {
/* 472 */       char temp = (char)bytearray[i];
/* 473 */       result = result + temp;
/*     */     } 
/* 475 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int binaryToAlgorism(String binary) {
/* 485 */     int max = binary.length();
/* 486 */     int result = 0;
/* 487 */     for (int i = max; i > 0; i--) {
/* 488 */       char c = binary.charAt(i - 1);
/* 489 */       int algorism = c - 48;
/* 490 */       result = (int)(result + Math.pow(2.0D, (max - i)) * algorism);
/*     */     } 
/* 492 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String algorismToHEXString(int algorism) {
/* 502 */     String result = "";
/* 503 */     result = Integer.toHexString(algorism);
/*     */     
/* 505 */     if (result.length() % 2 == 1) {
/* 506 */       result = "0" + result;
/*     */     }
/*     */     
/* 509 */     result = result.toUpperCase();
/*     */     
/* 511 */     return result;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String patchHexString(String str, int maxLength) {
/* 522 */     String temp = "";
/* 523 */     for (int i = 0; i < maxLength - str.length(); i++) {
/* 524 */       temp = "0" + temp;
/*     */     }
/* 526 */     str = (temp + str).substring(0, maxLength);
/* 527 */     return str;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int parseToInt(String s, int defaultInt, int radix) {
/* 539 */     int i = 0;
/*     */     try {
/* 541 */       i = Integer.parseInt(s, radix);
/* 542 */     } catch (NumberFormatException ex) {
/* 543 */       i = defaultInt;
/*     */     } 
/* 545 */     return i;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static int parseToInt(String s, int defaultInt) {
/* 556 */     int i = 0;
/*     */     try {
/* 558 */       i = Integer.parseInt(s);
/* 559 */     } catch (NumberFormatException ex) {
/* 560 */       i = defaultInt;
/*     */     } 
/* 562 */     return i;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static byte[] hexToByte(String hex) throws IllegalArgumentException {
/* 572 */     if (hex.length() % 2 != 0) {
/* 573 */       throw new IllegalArgumentException();
/*     */     }
/* 575 */     char[] arr = hex.toCharArray();
/* 576 */     byte[] b = new byte[hex.length() / 2];
/* 577 */     for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
/* 578 */       String swap = "" + arr[i++] + arr[i];
/* 579 */       int byteint = Integer.parseInt(swap, 16) & 0xFF;
/* 580 */       b[j] = (new Integer(byteint)).byteValue();
/*     */     } 
/* 582 */     return b;
/*     */   }
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */ 
/*     */   
/*     */   public static String byteToHex(byte[] b) {
/* 592 */     if (b == null) {
/* 593 */       throw new IllegalArgumentException("Argument b ( byte array ) is null! ");
/*     */     }
/*     */     
/* 596 */     String hs = "";
/* 597 */     String stmp = "";
/* 598 */     for (int n = 0; n < b.length; n++) {
/* 599 */       stmp = Integer.toHexString(b[n] & 0xFF);
/* 600 */       if (stmp.length() == 1) {
/* 601 */         hs = hs + "0" + stmp;
/*     */       } else {
/* 603 */         hs = hs + stmp;
/*     */       } 
/*     */     } 
/* 606 */     return hs.toLowerCase();
/*     */   }
/*     */ 
/*     */   
/*     */   public static byte[] subByte(byte[] input, int startIndex, int length) {
/* 611 */     byte[] bt = new byte[length];
/* 612 */     for (int i = 0; i < length; i++) {
/* 613 */       bt[i] = input[i + startIndex];
/*     */     }
/* 615 */     return bt;
/*     */   }
/*     */ }


/* Location:              C:\Users\ningj\Desktop\java-sdk-1.0.0-SNAPSHOT\!\cn\com\esgcc\ai\matrix\sd\\util\encrypt\Util.class
 * Java compiler version: 8 (52.0)
 * JD-Core Version:       1.1.3
 */