public byte[] getCompleteEncryptedCipherText() { if (explicitIv) { return ArrayConverter.concatenate(initialisationVector, encryptedCipherText); } else { return encryptedCipherText; } } }
Sender(String hex) { value = ArrayConverter.hexStringToByteArray(hex); }
public byte[] getByteValue() { return ArrayConverter.intToBytes(value, 2); }
private byte[] calculatePadding(BigInteger modulus, BigInteger topad) { byte[] padding; int modulusByteLength = ArrayConverter.bigIntegerToByteArray(modulus).length; byte[] paddingArray = ArrayConverter.bigIntegerToByteArray(topad); if (modulusByteLength == paddingArray.length) { return paddingArray; } int paddingByteLength = modulusByteLength - paddingArray.length; if (paddingByteLength < 0) { LOGGER.warn("Padding ByteLength negative, Using Zero instead"); paddingByteLength = 0; } padding = new byte[paddingByteLength]; return ArrayConverter.concatenate(padding, paddingArray); }
/** * Computes the HKDF-Label as defined in TLS 1.3 */ private static byte[] labelEncoder(byte[] hashValue, String labelIn, int outLen) { String label = "tls13 " + labelIn; int labelLength = label.getBytes().length; int hashValueLength = hashValue.length; byte[] result = ArrayConverter.concatenate(ArrayConverter.intToBytes(outLen, 2), ArrayConverter.intToBytes(labelLength, 1), label.getBytes(), ArrayConverter.intToBytes(hashValueLength, 1), hashValue); return result; }
private String toIndentedString(byte[] bytes) { return ArrayConverter.bytesToHexString(bytes).replace("\n", "\n "); }
/** * * @param message * @return */ protected boolean queryOracle(BigInteger message) { byte[] msg = ArrayConverter.bigIntegerToByteArray(message, blockSize, true); return oracle.checkPKCSConformity(msg); }
/** * Computes Chinese Reminder Theorem: x == congs[i] mod moduli[i] * * @param congs * A BigInteger[] of congestions * @param moduli * A BigInteger[] of moduli * @return Chinese Reminder Theorem: x == congs[i] mod moduli[i] */ public static BigInteger CRT(List<BigInteger> congs, List<BigInteger> moduli) { BigInteger[] cs = ArrayConverter.convertListToArray(congs); BigInteger[] ms = ArrayConverter.convertListToArray(moduli); return CRT(cs, ms); }
public BadRandom getBadSecureRandom() { return new BadRandom(getRandom(), null); }
public static TokenBindingVersion getExtensionType(byte[] value) { TokenBindingVersion type = MAP.get(ArrayConverter.bytesToInt(value)); return type; }
/** * Lists all the modifiable variables declared in the class * * @return List of all modifiableVariables declared in this class */ public List<Field> getAllModifiableVariableFields() { return ReflectionHelper.getFieldsUpTo(this.getClass(), null, ModifiableVariable.class); }
private byte[] calculatePadding(BigInteger modulus, BigInteger topad) { byte[] padding; int modulusByteLength = ArrayConverter.bigIntegerToByteArray(modulus).length; byte[] paddingArray = ArrayConverter.bigIntegerToByteArray(topad); if (modulusByteLength == paddingArray.length) { return paddingArray; } int paddingByteLength = modulusByteLength - paddingArray.length; if (paddingByteLength < 0) { LOGGER.warn("Negative SRP Padding Size. Using 0"); paddingByteLength = 0; } padding = new byte[paddingByteLength]; return ArrayConverter.concatenate(padding, paddingArray); }
private static byte[] addPadding(byte[] plaintextraw, int keysize) { byte padlen = (byte) (0xFF & (keysize - (plaintextraw.length % keysize))); byte[] padding = new byte[padlen]; for (int i = 0; i < padlen; i++) { padding[i] = padlen; } byte[] padded = ArrayConverter.concatenate(plaintextraw, padding); return padded; }
@Override public String marshal(X509CertificateObject v) throws Exception { return ArrayConverter.bytesToHexString(v.getEncoded()); }
@Override public byte[] convert(String value) { try { return ArrayConverter.hexStringToByteArray(value); } catch (IllegalArgumentException ex) { throw new ParameterException("Could not parse " + value + ". Not a hex String"); } }
public byte[] getByteValue() { return ArrayConverter.intToBytes(value, 2); }
/** * @param m * original message to be changed * @param si * factor * @return (m*si) mod N, or (m*si^e) mod N, depending on the oracle type, in * a byte array */ protected byte[] prepareMsg(BigInteger m, BigInteger si) { byte[] msg; BigInteger tmp = multiply(m, si); msg = ArrayConverter.bigIntegerToByteArray(tmp, blockSize, true); return msg; }
public static SrtpProtectionProfiles getProfileByType(byte[] value) { return MAP.get(ArrayConverter.bytesToInt(value)); }
public byte[] getClientServerRandom() { return ArrayConverter.concatenate(clientRandom, serverRandom); }
@Override public String toString() { StringBuilder sb = new StringBuilder(); sb.append("UnknownHandshakeMessage:"); sb.append("\n Data: "); if (data != null && data.getValue() != null) { sb.append(ArrayConverter.bytesToHexString(data.getValue())); } else { sb.append("null"); } return sb.toString(); }