python类MODE_CBC的实例源码

def uncipher(cipher, key):
    cipher += '=' * (-len(cipher) % 4)
    b64_decoded = base64.urlsafe_b64decode(cipher)
    uncipher = DES.new( key, DES.MODE_CBC, b64_decoded[:8] )
    clear = uncipher.decrypt(b64_decoded)
    padding = clear[-1]
    # Check padding
    if not all(c in padding for c in clear[-ord(padding):]):
        raise PaddingError()
    return clear[8:-ord(padding)]

def dblink11(self, data, options):
  key=binascii.unhexlify(data[2:18])
  pw=binascii.unhexlify(data[18:])

  cipher=DES.new(key, DES.MODE_CBC, '\0' * 8)
  return unpad(cipher.decrypt(pw))

def decrypt_des(key, data):
    iv = key
    cipher = DES.new(key, DES.MODE_CBC, iv)
    return cipher.decrypt(data)

def decrypt_aes(key, iv, data):
    mode = AES.MODE_CBC
    cipher = AES.new(key, mode, IV=iv)
    return cipher.decrypt(data)

def decrypt_des(data):
    key = '&%#@?,:*'
    iv = '\x12\x34\x56\x78\x90\xab\xcd\xef'
    cipher = DES.new(key, DES.MODE_CBC, iv)
    return cipher.decrypt(data)

def decryptData(self, decryptKey, privParameters, encryptedData):
        if DES is None:
            raise error.StatusInformation(
                errorIndication=errind.decryptionError
            )

        snmpEngineBoots, snmpEngineTime, salt = privParameters

        # 8.3.2.1
        if len(salt) != 8:
            raise error.StatusInformation(
                errorIndication=errind.decryptionError
            )

        # 8.3.2.2 noop

        # 8.3.2.3
        desKey, iv = self.__getDecryptionKey(decryptKey, salt)

        # 8.3.2.4 -> 8.1.1.3
        if len(encryptedData) % 8 != 0:
            raise error.StatusInformation(
                errorIndication=errind.decryptionError
            )

        desObj = DES.new(desKey, DES.MODE_CBC, iv)

        # 8.3.2.6
        return desObj.decrypt(encryptedData.asOctets())

def aes_encryption(incoming_shellcode, encryption_pad=4):
    # Generate a random key, create the cipher object
    # pad the shellcode, and encrypt the padded shellcode
    # return encrypted -> encoded shellcode and key
    random_aes_key = helpers.randomKey()
    iv = helpers.randomString(16)
    aes_cipher_object = AES.new(random_aes_key, AES.MODE_CBC, iv)
    padded_shellcode = encryption_padding(incoming_shellcode, encryption_pad)
    encrypted_shellcode = aes_cipher_object.encrypt(padded_shellcode)
    encoded_ciphertext = base64.b64encode(encrypted_shellcode)
    return encoded_ciphertext, random_aes_key, iv

def des_encryption(incoming_shellcode):
    # Generate a random key, create the cipher object
    # pad the shellcode, and encrypt the padded shellcode
    # return encrypted -> encoded shellcode and key
    random_des_key = helpers.randomKey(8)
    iv = helpers.randomString(8)
    des_cipher_object = DES.new(random_des_key, DES.MODE_CBC, iv)
    padded_shellcode = encryption_padding(incoming_shellcode)
    encrypted_shellcode = des_cipher_object.encrypt(padded_shellcode)
    encoded_ciphertext = base64.b64encode(encrypted_shellcode)
    return encoded_ciphertext, random_des_key, iv

def AesCbcEncryptEncoder(key=None, iv=None, key_size=16, key_provider=None, padder=None):
    '''
    AES CBC Encrypt encoder.
    See :class:`~katnip.model.low_level.encoder.AesEncryptEncoder` for parameter description.
    '''
    return AesEncryptEncoder(key, iv, AES.MODE_CBC, key_size, key_provider, padder)

def AesCbcDecryptEncoder(key=None, iv=None, key_size=16, key_provider=None):
    '''
    AES CBC Decrypt encoder.
    See :class:`~katnip.model.low_level.encoder.AesDecryptEncoder` for parameter description.
    '''
    return AesDecryptEncoder(key, iv, AES.MODE_CBC, key_size, key_provider)

def test_vanilla_CBC(self):
        self.crypto.mode = AES.MODE_CBC
        self.test_vanilla_base()

def setUp(self):
        crypt = CryptArgs('\x01' * 16, '\x00' * 16, 16, [16, 24, 32], AES.MODE_CBC, None)
        super(AesEncryptEncoderTestCase, self).setUp(crypt)
        self.crypto.padder = None

def test_AesCbcEncryptEncoder(self):
        '''
        AesCbcEncryptEncoder(key=None, iv=None, key_size=16, key_provider=None, padder=None)
        '''
        self.crypto.mode = AES.MODE_CBC
        self._test_generators_base(
            AesCbcEncryptEncoder(
                key=self.crypto.key,
                iv=self.crypto.iv,
                key_size=self.crypto.key_size,
                key_provider=self.crypto.key_provider,
                padder=self.crypto.padder
            ))

def test_AesCbcDecryptEncoder(self):
        '''
        AesCbcDecryptEncoder(key=None, iv=None, key_size=16, key_provider=None)
        '''
        self.crypto.mode = AES.MODE_CBC
        self._test_generators_base(
            AesCbcDecryptEncoder(
                key=self.crypto.key,
                iv=self.crypto.iv,
                key_size=self.crypto.key_size,
                key_provider=self.crypto.key_provider,
            ))

def setUp(self):
        crypt = CryptArgs('\x01' * 8, '\x00' * 8, 8, [8], DES.MODE_CBC, None)
        super(DesEncryptEncoderTestCase, self).setUp(crypt)
        self.crypto.padder = None

def setUp(self):
        crypt = CryptArgs('\x01' * 8, '\x00' * 8, 8, [8], DES.MODE_CBC, None)
        super(DesDecryptEncoderTestCase, self).setUp(crypt)

def setUp(self):
        crypt = CryptArgs('\x01' * 16, '\x00' * 8, 8, [16, 24], DES3.MODE_CBC, None)
        super(Des3EncryptEncoderTestCase, self).setUp(crypt)
        self.crypto.padder = None

def setUp(self):
        crypt = CryptArgs('\x01' * 16, '\x00' * 8, 8, [16, 24], DES3.MODE_CBC, None)
        super(Des3DecryptEncoderTestCase, self).setUp(crypt)

def populate_transform_menu(menu, obj, action_table):
    aes_menu = menu.addMenu("AES")
    aes_ecb_menu = aes_menu.addMenu("ECB mode")
    aes_cbc_menu = aes_menu.addMenu("CBC mode")
    action_table[aes_ecb_menu.addAction("Encrypt")] = lambda: obj.transform_with_key(lambda data, key: aes_encrypt_transform(data, key, AES.MODE_ECB, ""))
    action_table[aes_ecb_menu.addAction("Decrypt")] = lambda: obj.transform_with_key(lambda data, key: aes_decrypt_transform(data, key, AES.MODE_ECB, ""))
    action_table[aes_cbc_menu.addAction("Encrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: aes_encrypt_transform(data, key, AES.MODE_CBC, iv))
    action_table[aes_cbc_menu.addAction("Decrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: aes_decrypt_transform(data, key, AES.MODE_CBC, iv))

    blowfish_menu = menu.addMenu("Blowfish")
    blowfish_ecb_menu = blowfish_menu.addMenu("ECB mode")
    blowfish_cbc_menu = blowfish_menu.addMenu("CBC mode")
    action_table[blowfish_ecb_menu.addAction("Encrypt")] = lambda: obj.transform_with_key(lambda data, key: blowfish_encrypt_transform(data, key, Blowfish.MODE_ECB, ""))
    action_table[blowfish_ecb_menu.addAction("Decrypt")] = lambda: obj.transform_with_key(lambda data, key: blowfish_decrypt_transform(data, key, Blowfish.MODE_ECB, ""))
    action_table[blowfish_cbc_menu.addAction("Encrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: blowfish_encrypt_transform(data, key, Blowfish.MODE_CBC, iv))
    action_table[blowfish_cbc_menu.addAction("Decrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: blowfish_decrypt_transform(data, key, Blowfish.MODE_CBC, iv))

    cast_menu = menu.addMenu("CAST")
    cast_ecb_menu = cast_menu.addMenu("ECB mode")
    cast_cbc_menu = cast_menu.addMenu("CBC mode")
    action_table[cast_ecb_menu.addAction("Encrypt")] = lambda: obj.transform_with_key(lambda data, key: cast_encrypt_transform(data, key, CAST.MODE_ECB, ""))
    action_table[cast_ecb_menu.addAction("Decrypt")] = lambda: obj.transform_with_key(lambda data, key: cast_decrypt_transform(data, key, CAST.MODE_ECB, ""))
    action_table[cast_cbc_menu.addAction("Encrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: cast_encrypt_transform(data, key, CAST.MODE_CBC, iv))
    action_table[cast_cbc_menu.addAction("Decrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: cast_decrypt_transform(data, key, CAST.MODE_CBC, iv))

    des_menu = menu.addMenu("DES")
    des_ecb_menu = des_menu.addMenu("ECB mode")
    des_cbc_menu = des_menu.addMenu("CBC mode")
    action_table[des_ecb_menu.addAction("Encrypt")] = lambda: obj.transform_with_key(lambda data, key: des_encrypt_transform(data, key, DES.MODE_ECB, ""))
    action_table[des_ecb_menu.addAction("Decrypt")] = lambda: obj.transform_with_key(lambda data, key: des_decrypt_transform(data, key, DES.MODE_ECB, ""))
    action_table[des_cbc_menu.addAction("Encrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: des_encrypt_transform(data, key, DES.MODE_CBC, iv))
    action_table[des_cbc_menu.addAction("Decrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: des_decrypt_transform(data, key, DES.MODE_CBC, iv))

    des3_menu = menu.addMenu("Triple DES")
    des3_ecb_menu = des3_menu.addMenu("ECB mode")
    des3_cbc_menu = des3_menu.addMenu("CBC mode")
    action_table[des3_ecb_menu.addAction("Encrypt")] = lambda: obj.transform_with_key(lambda data, key: des3_encrypt_transform(data, key, DES3.MODE_ECB, ""))
    action_table[des3_ecb_menu.addAction("Decrypt")] = lambda: obj.transform_with_key(lambda data, key: des3_decrypt_transform(data, key, DES3.MODE_ECB, ""))
    action_table[des3_cbc_menu.addAction("Encrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: des3_encrypt_transform(data, key, DES3.MODE_CBC, iv))
    action_table[des3_cbc_menu.addAction("Decrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: des3_decrypt_transform(data, key, DES3.MODE_CBC, iv))

    rc2_menu = menu.addMenu("RC2")
    rc2_ecb_menu = rc2_menu.addMenu("ECB mode")
    rc2_cbc_menu = rc2_menu.addMenu("CBC mode")
    action_table[rc2_ecb_menu.addAction("Encrypt")] = lambda: obj.transform_with_key(lambda data, key: rc2_encrypt_transform(data, key, ARC2.MODE_ECB, ""))
    action_table[rc2_ecb_menu.addAction("Decrypt")] = lambda: obj.transform_with_key(lambda data, key: rc2_decrypt_transform(data, key, ARC2.MODE_ECB, ""))
    action_table[rc2_cbc_menu.addAction("Encrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: rc2_encrypt_transform(data, key, ARC2.MODE_CBC, iv))
    action_table[rc2_cbc_menu.addAction("Decrypt")] = lambda: obj.transform_with_key_and_iv(lambda data, key, iv: rc2_decrypt_transform(data, key, ARC2.MODE_CBC, iv))

    action_table[menu.addAction("RC4")] = lambda: obj.transform_with_key(lambda data, key: rc4_transform(data, key))
    action_table[menu.addAction("XOR")] = lambda: obj.transform_with_key(lambda data, key: xor_transform(data, key))

def pyherion(code):
    """
    Generates a crypted hyperion'esque version of python code using
    base64 and AES with a random key, wrapped in an exec() dynamic launcher.

    code = the python source code to encrypt

    Returns the encrypted python code as a string.
    """

    imports = list()
    codebase = list()

    # strip out all imports from the code so pyinstaller can properly
    # launch the code by preimporting everything at compiletime
    for line in code.split("\n"):
        if not line.startswith("#"): # ignore commented imports...
            if "import" in line:
                imports.append(line)
            else:
                codebase.append(line)

    # encrypt the input file (less the imports)
    encrypted_code, key, iv = aes_encryption("\n".join(codebase), encryption_pad='{')
    encrypted_code = encrypted_code.decode('ascii')

    # some random variable names
    b64var = helpers.randomString()
    aesvar = helpers.randomString()

    # randomize our base64 and AES importing variable
    imports.append("from base64 import b64decode as " + b64var)
    imports.append("from Crypto.Cipher import AES as " + aesvar)

    # shuffle up our imports
    random.shuffle(imports)

    # add in the AES imports and any imports found in the file
    crypted = ";".join(imports) + "\n"

    # the exec() launcher for our base64'ed encrypted string
    to_be_encoded = "exec(" + aesvar + ".new(\"" + key + "\", " + aesvar + ".MODE_CBC, \"" + iv + "\").decrypt(" + b64var + "(\"" + encrypted_code + "\")).rstrip(b'{'))\n"
    to_be_encoded = to_be_encoded.encode()
    encoded_script = base64.b64encode(to_be_encoded).decode('ascii')
    crypted += "exec(" + b64var + "(\"" + encoded_script + "\"))"

    return crypted