Decrypts the request after transmission.
191174
public void decrypt (byte[] key)
        throws IOException, ClassNotFoundException
    {
        if (_clearCreds != null) {
            return;
        }
        _key = key;
        try {
           _contents = SecureUtil.getAESCipher(Cipher.DECRYPT_MODE, _key).doFinal(_contents);
        } catch (GeneralSecurityException gse) {
            IOException ioe = new IOException("Failed to decrypt credentials");
            ioe.initCause(gse);
            throw ioe;
        }

        ByteArrayInputStream byteIn = new ByteArrayInputStream(_contents);
        ObjectInputStream cipherIn = new ObjectInputStream(byteIn);
        _clearCreds = (Credentials)cipherIn.readObject();
    }
1054503
public String decrypt(byte[] message, Charset charset) throws CryptoException {
		return StrUtil.str(crypt(message), charset);
	}
13582
def decrypt(source_text, passphrase, debug_stmt=None):
    
    if debug_stmt is None:
        debug_stmt = "decrypt"
    full_encrypted = b64decode(source_text)
    salt = full_encrypted[8:IV_BLOCK_SIZE]
    encrypted_text = full_encrypted[IV_BLOCK_SIZE:]
    key, iv_ = _openssl_key_iv(passphrase, salt)
    cipher = Cipher(
        algorithms.AES(key), modes.CBC(iv_), default_backend()
    ).decryptor()
    plain_text = cipher.update(encrypted_text)
    plain_text += cipher.finalize()
    # PKCS#7 padding
    if six.PY2:
        padding = ord(plain_text[-1])
    else:
        padding = plain_text[-1]
    plain_text = plain_text[:-padding]
    if hasattr(plain_text, 'decode'):
        plain_text = plain_text.decode('utf-8')
    _log_debug(salt, key, iv_, source_text, plain_text,
        passphrase=passphrase, debug_stmt=debug_stmt)
    return plain_text
440474
def decrypt(text):
    ''
    crypt = EncryptionAlgorithm.new(_get_encryption_key())
    return crypt.decrypt(text).rstrip(ENCRYPT_PAD_CHARACTER)
544586
function decrypt (str) {
    var decipher = crypto.createDecipher(algorithm, key)
      , dec = decipher.update(str, to, from) + decipher.final(from)
    return dec;
  }
727165
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
        ''''''

        q = 'getrawtransaction?txid={txid}&decrypt={decrypt}'.format(txid=txid, decrypt=decrypt)

        return cast(dict, self.api_fetch(q))
1034541
def decrypt(payload, private_key):
        """"""
        cipher = PKCS1_v1_5.new(private_key)
        aes_key_str = cipher.decrypt(b64decode(payload.get("aes_key")), sentinel=None)
        aes_key = json.loads(aes_key_str.decode("utf-8"))
        key = b64decode(aes_key.get("key"))
        iv = b64decode(aes_key.get("iv"))
        encrypted_magic_envelope = b64decode(payload.get("encrypted_magic_envelope"))
        encrypter = AES.new(key, AES.MODE_CBC, iv)
        content = encrypter.decrypt(encrypted_magic_envelope)
        return etree.fromstring(pkcs7_unpad(content))
860937
def Decrypt(self, encrypted_data):
    
    index_split = -(len(encrypted_data) % DES3.block_size)
    if index_split:
      remaining_encrypted_data = encrypted_data[index_split:]
      encrypted_data = encrypted_data[:index_split]
    else:
      remaining_encrypted_data = b''

    decrypted_data = self._des3_cipher.decrypt(encrypted_data)

    return decrypted_data, remaining_encrypted_data
1349002
def decrypt(self, value):
        """"""
        try:
            value, timestamp, signature = value.split("|")
        except ValueError:
            return None
        if check_signature(signature, self.secret, value + timestamp, encoding=self.encoding):
            return base64.b64decode(value).decode(self.encoding)
143656
function decrypt (input, firstKey = 0xAB) {
  const buf = Buffer.from(input);
  let key = firstKey;
  let nextKey;
  for (let i = 0; i < buf.length; i++) {
    nextKey = buf[i];
    buf[i] = buf[i] ^ key;
    key = nextKey;
  }
  return buf;
}
1318980
public static byte[] decryptAsBytes(final byte[] encryptedIvTextBytes) throws Exception {
        final SecretKey secretKey = KeyManager.getInstance().getSecretKey();
        return decryptAsBytes(secretKey, encryptedIvTextBytes);
    }
952385
def decrypt(self, msg, alg='aes_128_cbc', padding='PKCS#7', b64dec=True):
        
        self.__class__._deprecation_notice()
        data = _base64.b64decode(msg) if b64dec else msg

        cipher, iv = self.build_cipher(alg=alg)
        decryptor = cipher.decryptor()
        res = decryptor.update(data)[self.AES_BLOCK_SIZE:]
        res += decryptor.finalize()
        if padding in ['PKCS#5', 'PKCS#7']:
            idx = bytearray(res)[-1]
            res = res[:-idx]
        return res
989972
public static void decryptAsync(String encrypted, String password, RNCryptorNativeCallback RNCryptorNativeCallback) {
        String decrypted;
        try {
            decrypted = new RNCryptorNative().decrypt(encrypted, password);
            RNCryptorNativeCallback.done(decrypted, null);
        } catch (Exception e) {
            RNCryptorNativeCallback.done(null, e);
        }
    }
444681
def decrypt(secret, modN, d, blockSize):
    """"""
    numBlocks = [modExp(blocks, d, modN) for blocks in secret]
    numList = blocks2numList(numBlocks, blockSize)
    return numList2string(numList)
1285110
public String decrypt(String toDecrypt) {
        byte[] encryptedBytes = base64Decoder.decode(toDecrypt);
        return decryptInternal(dataEncryptionSecretKeySpec, encryptedBytes);
    }
101117
private void saveDecryptedPositions() {
        for (int i = 0; i < decryptedNetPosInfo.length; i++) {
            decryptedNetPosInfo[i] = 0;
        }
        if (null != getBuffers()) {
            WsByteBuffer[] buffers = getBuffers();
            if (buffers.length > decryptedNetPosInfo.length) {
                decryptedNetPosInfo = new int[buffers.length];
            }
            for (int i = 0; i < buffers.length && null != buffers[i]; i++) {
                decryptedNetPosInfo[i] = buffers[i].position();
            }
        }
    }
363459
public byte[] decrypt(String iv, String cipherText, Encoder encoder) {
        return decrypt(encoder.decode(iv), encoder.decode(cipherText));
    }