python类MODE_CBC的实例源码

def encrypt(self, data):
        """Encrypt sensitive data by KIK.
For (3)DES, data must be padded to BS.
For AES, if data not BS-alligned, they are padded by '80..00'"""
        l = len(data)
        if self.zAES:
            l %= 16
            if l > 0:
                data += '\x80' + '\0'*(15-l)
            key = AES.new(self.keyValue, AES.MODE_CBC, IV='\0'*16)
        else:
            # suppose 8B aligned data
            assert l % 8 == 0
            # for (3)DES KIK, ECB is used
            # KeyType.DES_IMPLICIT is supposed to be 3DES ECB
            if self.keyType in (KeyType.TDES_CBC, KeyType.DES_IMPLICIT):
                key = DES3.new(self.keyValue, DES.MODE_ECB)
            elif self.keyType in (KeyType.DES_ECB, KeyType.DES_CBC):
                key = DES.new(self.keyValue, DES.MODE_ECB)
            else:
                raise ValueError("Unknown key type %02X" % self.keyType)
        return key.encrypt(data)

def reencrypt(self, data):
        try:
            self.decoder = DES.new(self.key, DES.MODE_CBC, self.iv) # need to reinit it each time because of CBC
            decrypted=self.unpad(self.decoder.decrypt(base64.b64decode(data)))
            if debug:
                if len(decrypted)==8 and re.match(self.autogen,decrypted) is not None:
                    self.debugf.write(self.currentdn+" =* "+decrypted+"\n")
                elif re.match(self.alphanumchar,decrypted) is not None:
                    self.debugf.write(self.currentdn+" => "+decrypted+"\n")
                else:
                    self.debugf.write(self.currentdn+" =x "+decrypted+"\n")
            encrypted=self.encoder.encrypt(self.pad(decrypted))
            newdata=base64.b64encode(encrypted)
            return newdata
        except:
            raise

def __init__(self, iKICD):
        """ Constructor for KIC/KID object.
 iKICD - coding of KIC or KID (see ETSI 102.225, 5.1.2 and 5.1.3, u8)"""
        iKICD %= 0x100
        self.iKICD = iKICD
        self.keyval = None
        if iKICD & KICD.ALGO == KICD.ALGO_DES:           # DES/3DES key
            b43 = iKICD & 0x0C           # bits 4 and 3 of KIC/KID
            self.keysize = 8 + 2*(b43 % 12)  # mapping to DES, 3DES 2k, 3DES 3k
            self.cipModule = b43 % 12 and DES3 or DES
            self.MODE = b43 == KICD.DES_ECB and DES.MODE_EBC or DES.MODE_CBC
            self.BS = 8
            self.zAES = False
        elif iKICD & 0x0F == KICD.ALGO_AES:         # AES CBC / CMAC
            self.zAES = True
            self.cipModule = AES
            self.MODE = AES.MODE_CBC
            self.BS = 16
            self.TlenB = 8     # length of CMAC, you may manually change to 4
            self.irrPoly = 0x87            # for CMAC
        else:
            raise ValueError("Only DES/AES implemented for KIC/KID")

def sign(self, data):
        """
Sign data (as str) by KID key.
Return signature as str."""
        if self.zAES:
            data = [ord(x) for x in data]
            sLB = len(data) % self.BS
            if(sLB > 0 or len(data) == 0):
                data += [0x80] + [0]*(self.BS-sLB-1)
                xorkey = self.xorKey2
            else:
                xorkey = self.xorKey1
            for i in xrange(self.BS):
                data[-self.BS+i] ^= ord(xorkey[i])
            cipher = AES.new(self.keyval, AES.MODE_CBC, IV='\0'*16)
            data = ''.join([chr(x) for x in data])
            sig = cipher.encrypt(data)[-self.BS:]
            return sig[:self.TlenB]
        else:
            padlen = len(data) % self.BS
            if padlen > 0:
                padlen = self.BS - padlen
            sig = self.cipher(data + '\0'*padlen, True)
            return sig[-self.BS:]

def encryptData(self, encryptKey, privParameters, dataToEncrypt):
        if DES is None:
            raise error.StatusInformation(
                errorIndication=errind.encryptionError
            )

        snmpEngineBoots, snmpEngineTime, salt = privParameters

        # 8.3.1.1
        desKey, salt, iv = self.__getEncryptionKey(
            encryptKey, snmpEngineBoots
        )

        # 8.3.1.2
        privParameters = univ.OctetString(salt)

        # 8.1.1.2
        desObj = DES.new(desKey, DES.MODE_CBC, iv)
        plaintext = dataToEncrypt + univ.OctetString((0,) * (8 - len(dataToEncrypt) % 8)).asOctets()
        ciphertext = desObj.encrypt(plaintext)

        # 8.3.1.3 & 4
        return univ.OctetString(ciphertext), privParameters

    # 8.2.4.2

def encryptData(self, encryptKey, privParameters, dataToEncrypt):
        if DES is None:
            raise error.StatusInformation(
                errorIndication=errind.encryptionError
            )

        snmpEngineBoots, snmpEngineTime, salt = privParameters

        # 8.3.1.1
        desKey, salt, iv = self.__getEncryptionKey(
            encryptKey, snmpEngineBoots
        )

        # 8.3.1.2
        privParameters = univ.OctetString(salt)

        # 8.1.1.2
        desObj = DES.new(desKey, DES.MODE_CBC, iv)
        plaintext = dataToEncrypt + univ.OctetString((0,) * (8 - len(dataToEncrypt) % 8)).asOctets()
        ciphertext = desObj.encrypt(plaintext)

        # 8.3.1.3 & 4
        return univ.OctetString(ciphertext), privParameters

    # 8.2.4.2

def basic_encrypt(cls, key, plaintext):
        assert len(plaintext) % 8 == 0
        des = DES.new(key.contents, DES.MODE_CBC, '\0' * 8)
        return des.encrypt(plaintext)

def basic_decrypt(cls, key, ciphertext):
        assert len(ciphertext) % 8 == 0
        des = DES.new(key.contents, DES.MODE_CBC, '\0' * 8)
        return des.decrypt(ciphertext)

def basic_encrypt(cls, key, plaintext):
        assert len(plaintext) % 8 == 0
        des3 = DES3.new(key.contents, AES.MODE_CBC, '\0' * 8)
        return des3.encrypt(plaintext)

def basic_decrypt(cls, key, ciphertext):
        assert len(ciphertext) % 8 == 0
        des3 = DES3.new(key.contents, AES.MODE_CBC, '\0' * 8)
        return des3.decrypt(ciphertext)

def basic_encrypt(cls, key, plaintext):
        assert len(plaintext) >= 16
        aes = AES.new(key.contents, AES.MODE_CBC, '\0' * 16)
        ctext = aes.encrypt(_zeropad(plaintext, 16))
        if len(plaintext) > 16:
            # Swap the last two ciphertext blocks and truncate the
            # final block to match the plaintext length.
            lastlen = len(plaintext) % 16 or 16
            ctext = ctext[:-32] + ctext[-16:] + ctext[-32:-16][:lastlen]
        return ctext

def wrapAPDU(self, apdu):
        """ Wrap APDU for SCP02, i.e. calculate MAC and encrypt.
Input APDU and output APDU are list of uint8. """
        lc = len(apdu) - 5
        assert len(apdu) >= 5, "Wrong APDU length: %d" % len(apdu)
        assert len(apdu) == 5 or apdu[4] == lc, \
            "Lc differs from length of data: %d vs %d" % (apdu[4], lc)

        cla = apdu[0]
        b8 = cla & 0x80
        if cla & 0x03 > 0 or cla & 0x40 != 0:
            # nonzero logical channel in APDU, check that are the same
            assert cla == self.CLA(False, b8), "CLA mismatch"
        sapdu = l2s(apdu)
        # CLA without log. channel can be 80 or 00 only
        if self.isCMAC:
            if self.i & M_CMAC_MODIF:  # CMAC on unmodified APDU
                mlc = lc
                clac = chr(b8)
            else:                      # CMAC on modified APDU
                mlc = lc + 8
                clac = chr(b8 + 0x04)
            mac = self.calcMAC_1d(clac + sapdu[1:4] + chr(mlc) + sapdu[5:])
            mac = [ord(x) for x in mac]
            if self.isENC:
                k = DES3.new(self.ses_ENC, DES.MODE_CBC, ZERO8)
                data = s2l(k.encrypt(pad80(sapdu[5:], 8)))
                lc = len(data)
            else:
                data = apdu[5:]
            lc += 8
            apdu = [self.CLA(True, b8)] + apdu[1:4] + [lc] + data + mac
        return apdu

def deriveKeys(self, card_challenge):
        """ Derive session keys and calculate host_ and card_ cryptograms."""

        # session keys derivation
        k = DES3.new(self.i & M_BASEKEY and self.base_S_MAC or self.base_KEY,
                     DES.MODE_CBC, IV=ZERO8)
        self.ses_C_MAC = k.encrypt(unhexlify("0101") + self.seqCounter +
                                   ZERO12)
        k = DES3.new(self.i & M_BASEKEY and self.base_S_MAC or self.base_KEY,
                     DES.MODE_CBC, IV=ZERO8)
        self.ses_R_MAC = k.encrypt(unhexlify("0102") + self.seqCounter +
                                   ZERO12)

        k = DES3.new(self.i & M_BASEKEY and self.base_DEK or self.base_KEY,
                     DES.MODE_CBC, IV=ZERO8)
        self.ses_DEK = k.encrypt(unhexlify("0181") + self.seqCounter + ZERO12)

        k = DES3.new(self.i & M_BASEKEY and self.base_S_ENC or self.base_KEY,
                     DES.MODE_CBC, IV=ZERO8)
        self.ses_ENC = k.encrypt(unhexlify("0182") + self.seqCounter + ZERO12)

        # key for MAC encryption
        if self.i & M_ICV_ENC:
            self.k_icv = DES.new(self.ses_C_MAC[:8], DES.MODE_ECB)

        # card cryptogram calculation
        if self.i & M_PSEUDO:
            self.card_challenge = self.calcMAC_1d(self.SD_AID, True)[:6]
        else:
            assert len(card_challenge) == 6,\
                "Wrong length or missing card challenge (mandatory)"
            self.card_challenge = card_challenge

        self.host_cryptogram = self.calcMAC_3d(self.seqCounter +
                                               self.card_challenge +
                                               self.host_challenge)
        self.card_cryptogram = self.calcMAC_3d(self.host_challenge +
                                               self.seqCounter +
                                               self.card_challenge)

def basic_encrypt(cls, key, plaintext):
        assert len(plaintext) % 8 == 0
        des = DES.new(key.contents, DES.MODE_CBC, '\0' * 8)
        return des.encrypt(plaintext)

def basic_decrypt(cls, key, ciphertext):
        assert len(ciphertext) % 8 == 0
        des = DES.new(key.contents, DES.MODE_CBC, '\0' * 8)
        return des.decrypt(ciphertext)

def basic_encrypt(cls, key, plaintext):
        assert len(plaintext) % 8 == 0
        des3 = DES3.new(key.contents, AES.MODE_CBC, '\0' * 8)
        return des3.encrypt(plaintext)

def basic_decrypt(cls, key, ciphertext):
        assert len(ciphertext) % 8 == 0
        des3 = DES3.new(key.contents, AES.MODE_CBC, '\0' * 8)
        return des3.decrypt(ciphertext)

def basic_encrypt(cls, key, plaintext):
        assert len(plaintext) >= 16
        aes = AES.new(key.contents, AES.MODE_CBC, '\0' * 16)
        ctext = aes.encrypt(_zeropad(plaintext, 16))
        if len(plaintext) > 16:
            # Swap the last two ciphertext blocks and truncate the
            # final block to match the plaintext length.
            lastlen = len(plaintext) % 16 or 16
            ctext = ctext[:-32] + ctext[-16:] + ctext[-32:-16][:lastlen]
        return ctext

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 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 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(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 decryptPBEWithMD5AndDES(plain, password, salt, iterations):
    key, iv = compute_key_iv(password, salt, iterations)
    decode = DES.new(key, DES.MODE_CBC, iv)
    decrypted = decode.decrypt(plain)
    decrypted = unpad(decrypted)
    return decrypted

def decrypt(plain, password, salt, iterations=20):
    key, iv = compute_key_iv(password, salt, iterations)
    decode = DES.new(key, DES.MODE_CBC, iv)
    decrypted = decode.decrypt(plain)
    decrypted = unpad_pkcs7(decrypted)
    return decrypted

def decrypt(plain, password, salt, iterations=20):
    key, iv = compute_key_iv(password, salt, iterations)
    decode = DES.new(key, DES.MODE_CBC, iv)
    decrypted = decode.decrypt(plain)
    decrypted = unpad_pkcs7(decrypted)
    return decrypted

def cipher(clear, key, IV):
    pad_len = 8 - len(clear) % 8 # length of padding
    padding = chr(pad_len) * pad_len # PKCS5 padding content
    clear += padding
    cipher = DES.new( key, DES.MODE_CBC, IV )
    return base64.urlsafe_b64encode(IV + cipher.encrypt(clear))