package com.mbridge.msdk.thrid.okio; import com.umeng.analytics.pro.cb; import java.io.EOFException; import java.io.IOException; import java.io.InputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.OutputStream; import java.io.Serializable; import java.lang.reflect.Field; import java.nio.ByteBuffer; import java.nio.charset.Charset; import java.security.InvalidKeyException; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Arrays; import javax.crypto.Mac; import javax.crypto.spec.SecretKeySpec; import kotlin.UByte; public class ByteString implements Serializable, Comparable<ByteString> { public static final ByteString EMPTY = of(new byte[0]); static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; private static final long serialVersionUID = 1; final byte[] data; transient int hashCode; transient String utf8; ByteString(byte[] bArr) { this.data = bArr; } public static ByteString of(byte... bArr) { if (bArr != null) { return new ByteString((byte[]) bArr.clone()); } throw new IllegalArgumentException("data == null"); } public static ByteString of(byte[] bArr, int i, int i2) { if (bArr != null) { Util.checkOffsetAndCount((long) bArr.length, (long) i, (long) i2); byte[] bArr2 = new byte[i2]; System.arraycopy(bArr, i, bArr2, 0, i2); return new ByteString(bArr2); } throw new IllegalArgumentException("data == null"); } public static ByteString of(ByteBuffer byteBuffer) { if (byteBuffer != null) { byte[] bArr = new byte[byteBuffer.remaining()]; byteBuffer.get(bArr); return new ByteString(bArr); } throw new IllegalArgumentException("data == null"); } public static ByteString encodeUtf8(String str) { if (str != null) { ByteString byteString = new ByteString(str.getBytes(Util.UTF_8)); byteString.utf8 = str; return byteString; } throw new IllegalArgumentException("s == null"); } public static ByteString encodeString(String str, Charset charset) { if (str == null) { throw new IllegalArgumentException("s == null"); } else if (charset != null) { return new ByteString(str.getBytes(charset)); } else { throw new IllegalArgumentException("charset == null"); } } public String utf8() { String str = this.utf8; if (str != null) { return str; } String str2 = new String(this.data, Util.UTF_8); this.utf8 = str2; return str2; } public String string(Charset charset) { if (charset != null) { return new String(this.data, charset); } throw new IllegalArgumentException("charset == null"); } public String base64() { return Base64.encode(this.data); } public ByteString md5() { return digest("MD5"); } public ByteString sha1() { return digest("SHA-1"); } public ByteString sha256() { return digest("SHA-256"); } public ByteString sha512() { return digest("SHA-512"); } private ByteString digest(String str) { try { return of(MessageDigest.getInstance(str).digest(this.data)); } catch (NoSuchAlgorithmException e) { throw new AssertionError(e); } } public ByteString hmacSha1(ByteString byteString) { return hmac("HmacSHA1", byteString); } public ByteString hmacSha256(ByteString byteString) { return hmac("HmacSHA256", byteString); } public ByteString hmacSha512(ByteString byteString) { return hmac("HmacSHA512", byteString); } private ByteString hmac(String str, ByteString byteString) { try { Mac instance = Mac.getInstance(str); instance.init(new SecretKeySpec(byteString.toByteArray(), str)); return of(instance.doFinal(this.data)); } catch (NoSuchAlgorithmException e) { throw new AssertionError(e); } catch (InvalidKeyException e2) { throw new IllegalArgumentException(e2); } } public String base64Url() { return Base64.encodeUrl(this.data); } public static ByteString decodeBase64(String str) { if (str != null) { byte[] decode = Base64.decode(str); if (decode != null) { return new ByteString(decode); } return null; } throw new IllegalArgumentException("base64 == null"); } public String hex() { byte[] bArr = this.data; char[] cArr = new char[(bArr.length * 2)]; int i = 0; for (byte b : bArr) { int i2 = i + 1; char[] cArr2 = HEX_DIGITS; cArr[i] = cArr2[(b >> 4) & 15]; i = i2 + 1; cArr[i2] = cArr2[b & cb.m]; } return new String(cArr); } public static ByteString decodeHex(String str) { if (str == null) { throw new IllegalArgumentException("hex == null"); } else if (str.length() % 2 == 0) { int length = str.length() / 2; byte[] bArr = new byte[length]; for (int i = 0; i < length; i++) { int i2 = i * 2; bArr[i] = (byte) ((decodeHexDigit(str.charAt(i2)) << 4) + decodeHexDigit(str.charAt(i2 + 1))); } return of(bArr); } else { throw new IllegalArgumentException("Unexpected hex string: " + str); } } private static int decodeHexDigit(char c) { if (c >= '0' && c <= '9') { return c - '0'; } char c2 = 'a'; if (c < 'a' || c > 'f') { c2 = 'A'; if (c < 'A' || c > 'F') { throw new IllegalArgumentException("Unexpected hex digit: " + c); } } return (c - c2) + 10; } public static ByteString read(InputStream inputStream, int i) throws IOException { if (inputStream == null) { throw new IllegalArgumentException("in == null"); } else if (i >= 0) { byte[] bArr = new byte[i]; int i2 = 0; while (i2 < i) { int read = inputStream.read(bArr, i2, i - i2); if (read != -1) { i2 += read; } else { throw new EOFException(); } } return new ByteString(bArr); } else { throw new IllegalArgumentException("byteCount < 0: " + i); } } public ByteString toAsciiLowercase() { int i = 0; while (true) { byte[] bArr = this.data; if (i >= bArr.length) { return this; } byte b = bArr[i]; if (b < 65 || b > 90) { i++; } else { byte[] bArr2 = (byte[]) bArr.clone(); bArr2[i] = (byte) (b + 32); for (int i2 = i + 1; i2 < bArr2.length; i2++) { byte b2 = bArr2[i2]; if (b2 >= 65 && b2 <= 90) { bArr2[i2] = (byte) (b2 + 32); } } return new ByteString(bArr2); } } } public ByteString toAsciiUppercase() { int i = 0; while (true) { byte[] bArr = this.data; if (i >= bArr.length) { return this; } byte b = bArr[i]; if (b < 97 || b > 122) { i++; } else { byte[] bArr2 = (byte[]) bArr.clone(); bArr2[i] = (byte) (b - 32); for (int i2 = i + 1; i2 < bArr2.length; i2++) { byte b2 = bArr2[i2]; if (b2 >= 97 && b2 <= 122) { bArr2[i2] = (byte) (b2 - 32); } } return new ByteString(bArr2); } } } public ByteString substring(int i) { return substring(i, this.data.length); } public ByteString substring(int i, int i2) { if (i >= 0) { byte[] bArr = this.data; if (i2 <= bArr.length) { int i3 = i2 - i; if (i3 < 0) { throw new IllegalArgumentException("endIndex < beginIndex"); } else if (i == 0 && i2 == bArr.length) { return this; } else { byte[] bArr2 = new byte[i3]; System.arraycopy(bArr, i, bArr2, 0, i3); return new ByteString(bArr2); } } else { throw new IllegalArgumentException("endIndex > length(" + this.data.length + ")"); } } else { throw new IllegalArgumentException("beginIndex < 0"); } } public byte getByte(int i) { return this.data[i]; } public int size() { return this.data.length; } public byte[] toByteArray() { return (byte[]) this.data.clone(); } /* access modifiers changed from: package-private */ public byte[] internalArray() { return this.data; } public ByteBuffer asByteBuffer() { return ByteBuffer.wrap(this.data).asReadOnlyBuffer(); } public void write(OutputStream outputStream) throws IOException { if (outputStream != null) { outputStream.write(this.data); return; } throw new IllegalArgumentException("out == null"); } /* access modifiers changed from: package-private */ public void write(Buffer buffer) { byte[] bArr = this.data; buffer.write(bArr, 0, bArr.length); } public boolean rangeEquals(int i, ByteString byteString, int i2, int i3) { return byteString.rangeEquals(i2, this.data, i, i3); } public boolean rangeEquals(int i, byte[] bArr, int i2, int i3) { if (i >= 0) { byte[] bArr2 = this.data; return i <= bArr2.length - i3 && i2 >= 0 && i2 <= bArr.length - i3 && Util.arrayRangeEquals(bArr2, i, bArr, i2, i3); } } public final boolean startsWith(ByteString byteString) { return rangeEquals(0, byteString, 0, byteString.size()); } public final boolean startsWith(byte[] bArr) { return rangeEquals(0, bArr, 0, bArr.length); } public final boolean endsWith(ByteString byteString) { return rangeEquals(size() - byteString.size(), byteString, 0, byteString.size()); } public final boolean endsWith(byte[] bArr) { return rangeEquals(size() - bArr.length, bArr, 0, bArr.length); } public final int indexOf(ByteString byteString) { return indexOf(byteString.internalArray(), 0); } public final int indexOf(ByteString byteString, int i) { return indexOf(byteString.internalArray(), i); } public final int indexOf(byte[] bArr) { return indexOf(bArr, 0); } public int indexOf(byte[] bArr, int i) { int length = this.data.length - bArr.length; for (int max = Math.max(i, 0); max <= length; max++) { if (Util.arrayRangeEquals(this.data, max, bArr, 0, bArr.length)) { return max; } } return -1; } public final int lastIndexOf(ByteString byteString) { return lastIndexOf(byteString.internalArray(), size()); } public final int lastIndexOf(ByteString byteString, int i) { return lastIndexOf(byteString.internalArray(), i); } public final int lastIndexOf(byte[] bArr) { return lastIndexOf(bArr, size()); } public int lastIndexOf(byte[] bArr, int i) { for (int min = Math.min(i, this.data.length - bArr.length); min >= 0; min--) { if (Util.arrayRangeEquals(this.data, min, bArr, 0, bArr.length)) { return min; } } return -1; } public boolean equals(Object obj) { if (obj == this) { return true; } if (obj instanceof ByteString) { ByteString byteString = (ByteString) obj; int size = byteString.size(); byte[] bArr = this.data; if (size != bArr.length || !byteString.rangeEquals(0, bArr, 0, bArr.length)) { return false; } return true; } return false; } public int hashCode() { int i = this.hashCode; if (i != 0) { return i; } int hashCode2 = Arrays.hashCode(this.data); this.hashCode = hashCode2; return hashCode2; } public int compareTo(ByteString byteString) { int size = size(); int size2 = byteString.size(); int min = Math.min(size, size2); for (int i = 0; i < min; i++) { int i2 = getByte(i) & UByte.MAX_VALUE; int i3 = byteString.getByte(i) & UByte.MAX_VALUE; if (i2 != i3) { if (i2 < i3) { return -1; } else { return 1; } } } if (size == size2) { return 0; } if (size < size2) { return -1; } return 1; } public String toString() { StringBuilder sb; if (this.data.length == 0) { return "[size=0]"; } String utf82 = utf8(); int codePointIndexToCharIndex = codePointIndexToCharIndex(utf82, 64); if (codePointIndexToCharIndex != -1) { String replace = utf82.substring(0, codePointIndexToCharIndex).replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r"); if (codePointIndexToCharIndex < utf82.length()) { sb = new StringBuilder(); sb.append("[size="); sb.append(this.data.length); sb.append(" text="); sb.append(replace); sb.append("…]"); } else { sb = new StringBuilder(); sb.append("[text="); sb.append(replace); sb.append("]"); } return sb.toString(); } else if (this.data.length <= 64) { return "[hex=" + hex() + "]"; } else { return "[size=" + this.data.length + " hex=" + substring(0, 64).hex() + "…]"; } } static int codePointIndexToCharIndex(String str, int i) { int length = str.length(); int i2 = 0; int i3 = 0; while (i2 < length) { if (i3 == i) { return i2; } int codePointAt = str.codePointAt(i2); if ((Character.isISOControl(codePointAt) && codePointAt != 10 && codePointAt != 13) || codePointAt == 65533) { return -1; } i3++; i2 += Character.charCount(codePointAt); } return str.length(); } private void readObject(ObjectInputStream objectInputStream) throws IOException { ByteString read = read(objectInputStream, objectInputStream.readInt()); try { Field declaredField = ByteString.class.getDeclaredField("data"); declaredField.setAccessible(true); declaredField.set(this, read.data); } catch (NoSuchFieldException unused) { throw new AssertionError(); } catch (IllegalAccessException unused2) { throw new AssertionError(); } } private void writeObject(ObjectOutputStream objectOutputStream) throws IOException { objectOutputStream.writeInt(this.data.length); objectOutputStream.write(this.data); } }