def fcn_3DES_CBC(isCrypt, master, text): # process the master key _masterKey(master) # prepare the input text inputText = text if not isCrypt: # is decrypt and the input is hexa string inputText = "".join([ chr(int(text[i:i+2], 16)) for i in range(0, len(text), 2) ]) # get the 3des key and iv mKey = _mkSeedDigest[0:24] mIV = _mkSeedDigest[-8:] # create the triple-des object and decrypt cipher = pyDes.triple_des(mKey, pyDes.CBC, mIV, pad=None, padmode=pyDes.PAD_PKCS5) # crypt or decrypt value = cipher.encrypt(inputText) if isCrypt else cipher.decrypt(inputText) # make printable (if needed) if isCrypt: value = "".join( [ "%02.2x" % ord(i) for i in value ] ) return value
def tpv_sig_data(mdata, order, key, alt=b"+/"): k = b64decode(key.encode(), alt) x = triple_des(k, CBC, b"\0\0\0\0\0\0\0\0", pad="\0") okey = x.encrypt(order.encode()) sig = hmac.new(okey, mdata.encode(), sha256).digest() sigb = b64encode(sig, alt).decode() return sigb
def main(): call('clear') print "Coldfusion DataSource Password Decryptor" print "Witten by James Luther" print " " parser = optparse.OptionParser(usage='%prog -p <hash>\n\nThis uses the' +\ ' default seed value unleess one is spe' +\ 'cified with -s <"seed">\n', version='%' +\ 'prog Version 2.1\n') parser.add_option('-p','--hash',dest='hash',type='string',help='Coldfus' +\ 'ion Password Hash') parser.add_option('-s','--seed',dest='seed',type='string',help='Custom' +\ 'seed value (must be in quotes)') (options, args) = parser.parse_args() pwd = options.hash seed = "0yJ!@1$r8p0L@r1$6yJ!@1rj" key = pyDes.triple_des(seed) if (pwd == None): print parser.usage exit(0) if (options.seed != None): seed = options.seed decryptkey(key, pwd)
def decrypt (data): # hex2bin ct = a2b_hex (data) # Extract the encrypted password enc = ct[40:] # Extract the IV iv = ct[:8] # Construct the key ht = ct[:19] + chr(ord(ct[19])+1) key = hashlib.sha1(ht).digest() ht = ht[:19] + chr(ord(ht[19])+2) key += hashlib.sha1(ht).digest()[:4] # Decrypt the password des = pyDes.triple_des (key, pyDes.CBC, iv)#, padmode = pyDes.PAD_PKCS5) pwd = des.decrypt (enc) print ord(pwd[-1]) return pwd #[:-1]
def kcdecrypt(key, iv, data): if len(data) == 0: #print>>stderr, "FileSize is 0" return data if len(data) % BLOCKSIZE != 0: return data cipher = triple_des(key, CBC, iv) # the line below is for pycrypto instead #cipher = DES3.new( key, DES3.MODE_CBC, iv ) plain = cipher.decrypt(data) # now check padding pad = ord(plain[-1]) if pad > 8: #print>> stderr, "Bad padding byte. You probably have a wrong password" return '' for z in plain[-pad:]: if ord(z) != pad: #print>> stderr, "Bad padding. You probably have a wrong password" return '' plain = plain[:-pad] return plain
def encrypt_pydes(self, command): from pyDes import triple_des hashed_command = self.hash(command) des = triple_des(self.secret) result = des.encrypt(hashed_command) return result.encode('hex')
def DecryptBlock(key, text): # Static salt salt = '\x83\x7D\xFC\x0F\x8E\xB3\xE8\x69\x73\xAF\xFF' # Master password notes: # # This *only* encrypts pasword fields, not username/etc. fields. # According to http://nontroppo.org/test/Op7/FAQ/opera-users.html#wand-security # "if you do use a master password, the used password is a combination of the # master password and a 128-byte random portion created at the same time. # This random portion is stored outside wand.dat, also encrypted with the # master password." # Random portion mentioned seems to be opcert6.dat # # According to http://my.opera.com/community/forums/topic.dml?id=132880 # "opcert6.dat contains all private keys you have created and the associated # client certificates you have requested and installed. The private keys are # protected by the security password. [...] A small block of data in the # opcert6.dat file is also used when you secure the wand and mail passwords # with the security password." h = hashlib.md5(salt + key).digest() h2 = hashlib.md5(h + salt + key).digest() key = h[:16] + h2[:8] iv = h2[-8:] if fastdes: return M2Crypto.EVP.Cipher(alg='des_ede3_cbc', key=key, iv=iv, op=0, padding=0).update(text) else: #print(pyDes.triple_des(key, pyDes.CBC, iv).decrypt(text)) return pyDes.triple_des(key, pyDes.CBC, iv).decrypt(text)
def UserEncryption(username,password): key=GetKeyID()[0:24] content=str(username)+'&*&'+password k = pyDes.triple_des(key,pyDes.CBC, lv, pad=None,padmode=pyDes.PAD_PKCS5) d = k.encrypt(content) s = binascii.hexlify(d) return base64.b64encode(s)
def encrypt(self, data): iv = binascii.unhexlify(self.iv) key = binascii.unhexlify(self.key) k = pyDes.triple_des(key, pyDes.CBC, iv, pad=None, padmode=pyDes.PAD_PKCS5) d = k.encrypt(data) d = base64.encodestring(d) return d
def make_tripleDES(): return pyDes.triple_des( derive_md5_key(settings.SECRET_KEY), pyDes.CBC, IV="\0\0\0\0\0\0\0\0", padmode=pyDes.PAD_PKCS5 )
def kcdecrypt( key, iv, data ): if len(data) % BLOCKSIZE != 0: raise "Bad decryption data len isn't a blocksize multiple" cipher = triple_des( key, CBC, iv ) # the line below is for pycrypto instead #cipher = DES3.new( key, DES3.MODE_CBC, iv ) plain = cipher.decrypt( data ) # now check padding pad = ord(plain[-1]) if pad > 8: print>>stderr, "Bad padding byte. You probably have a wrong password" exit(1) for z in plain[-pad:]: if ord(z) != pad: print>>stderr, "Bad padding. You probably have a wrong password" exit(1) plain = plain[:-pad] return plain
def __init__(self, key): if len(key) < 24: key = key + b64encode(key.encode("utf-8")) key = key + b64encode(key.encode("utf-8")) * 2 key = key[0:24] self.k = pyDes.triple_des(key.encode("utf-8"), CBC, "12345678", pad=None, padmode=PAD_PKCS5)
def encrypt_pydes(self, command): hashed_command = self.hash(command) des = triple_des(self.secret) result = des.encrypt(hashed_command) if sys.version_info[0] < 3: return result.encode('hex') else: return result.hex()
def decode(data): if not data: return '' k = pyDes.triple_des((str(uuid.getnode()) * 2)[0:24], pyDes.CBC, "\0\0\0\0\0\0\0\0", padmode=pyDes.PAD_PKCS5) return k.decrypt(base64.b64decode(data))
def __init__(self,acc,pwd,mac,server,key): self._acc=acc self._pwd=pwd self._mac=mac self._server=server self._key=key self._aes=pyAes.new(key,1) self._des=pyDes.triple_des('1234ZHEJIANGXINLIWANGLEI',pyDes.CBC,'12345678')
def decrypt(data, pinid): key = get_wxlt_config(pinid).get('des_key') if len(key) < 24: key += ' ' * (24 - len(key)) if len(key) > 24: key = key[:24] vi = '12345678' data = b64decode(data) k = triple_des(key, CBC, vi, pad=None, padmode=PAD_PKCS5) d = k.decrypt(data) return d
def decode_private_key(): # Before anything else, let's get the four passwords. print print "We need four passwords to decrypt your private key" print "Enter the words, one at a time, when prompted." print global options if options.pass1: p1 = options.pass1 else: p1 = getpass.getpass("Password One: ") if options.pass2: p2 = options.pass2 else: p2 = getpass.getpass("Password Two: ") if options.pass3: p3 = options.pass3 else: p3 = getpass.getpass("Password Three: ") if options.pass4: p4 = options.pass4 else: p4 = getpass.getpass("Password Four: ") whole_pass = p3+p1+p2+p4 # Concatenate the passwords # # Create a 48-bit has based on the string of the passwords # Then, based on the value of bit 7 of the last byte, # Use either the upper or low half of the hash value # Because TripleDES requires a 24-bit seed key thingy. # scram = hashlib.sha384(whole_pass).digest() hi_lo = ord(scram[47]) & 0x80 # Use the hash to figure out which half to use if hi_lo: scram_half = scram[:24] else: scram_half = scram[24:] # Create a TripleDES encryptor for the key k = pyDes.triple_des(scram_half, pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5) # Create encryptor privkey_fn = os.path.join(os.path.expanduser('~'),'.cryptweet-privkey-sec') # Path to secure private keyfile privkey_encrypted_file = open(privkey_fn, "r") privkey_encrypted = privkey_encrypted_file.read() privkey_encrypted_file.close() # Decrypt the file, if we can, then convert it to an object try: privkey_pem = k.decrypt(privkey_encrypted) privkey = rsa.PrivateKey.load_pkcs1(privkey_pem, format='PEM') # @sylmobile bug reported 12 Feb except: print "Encryption failure -- bad passwords?" return None return privkey
def sk_decode(request,password): iv = md5(password.encode('utf-8')).hexdigest() if len(iv) >=24: iv = iv[0:24] else: iv = iv+"0"*(24-len(iv)) k = triple_des(iv,padmode=PAD_PKCS5) result = k.decrypt(base64.b64decode(request)).decode("utf8") return result;
def decrypt(self, data): iv = binascii.unhexlify(self.iv) key = binascii.unhexlify(self.key) k = pyDes.triple_des(key, pyDes.CBC, iv, pad=None, padmode=pyDes.PAD_PKCS5) try: data = base64.decodestring(data) d = k.decrypt(data) except: d = '' return d
def _authenticate(self, password): from pyDes import triple_des, CBC # The first 16 password character bytes are taken as key # unless the password is empty. If it's empty we use the # factory default password. key = password[0:16] if password != "" else "IEMKAERB!NACUOYF" if len(key) != 16: raise ValueError("password must be at least 16 byte") log.debug("authenticate with key " + str(key).encode("hex")) rsp = self.transceive("\x1A\x00", rlen=9) m1 = str(rsp[1:9]) iv = "\x00\x00\x00\x00\x00\x00\x00\x00" rb = triple_des(key, CBC, iv).decrypt(m1) log.debug("received challenge") log.debug("iv = " + str(iv).encode("hex")) log.debug("m1 = " + str(m1).encode("hex")) log.debug("rb = " + str(rb).encode("hex")) ra = os.urandom(8) iv = str(rsp[1:9]) m2 = triple_des(key, CBC, iv).encrypt(ra + rb[1:8] + rb[0]) log.debug("sending response") log.debug("ra = " + str(ra).encode("hex")) log.debug("iv = " + str(iv).encode("hex")) log.debug("m2 = " + str(m2).encode("hex")) try: rsp = self.transceive("\xAF" + m2, rlen=9) except tt2.Type2TagCommandError: return False m3 = str(rsp[1:9]) iv = m2[8:16] log.debug("received confirmation") log.debug("iv = " + str(iv).encode("hex")) log.debug("m3 = " + str(m3).encode("hex")) return triple_des(key, CBC, iv).decrypt(m3) == ra[1:9] + ra[0]
def encrypt(plain): import pyDes, iPXSettings from binascii import hexlify key = iPXSettings.getVar('3DESKey') key = key.decode('rot-13') k = pyDes.triple_des(key) d = k.encrypt(plain.strip(), ' ') return hexlify(d)
def __init__(self,acc,pwd,mac=None,pre='/tmp/'): self._server='pppoeh.114school.cn' self._acc=acc self._pwd=pwd self._prefix=pre self._aes=pyAes.new('xlzjhrprotocol3x',1) self._des=pyDes.triple_des('1234ZHEJIANGXINLIWANGLEI',pyDes.CBC,'12345678') if mac: self._mac=mac else: self._mac='08:00:27:00:24:FD'
def get_token (): key_decoded = base64.b64decode( TPSENCRYPTKEY ) enc_obj = pyDes.triple_des( key=key_decoded, mode=pyDes.ECB, padmode=pyDes.PAD_PKCS5 ) ms_since_epoch = str( int( time.time() ) * 1000 ) # ms, not just time.time() in s plaintext_token = '%s|%s|%s' % ( TPSHOSTNAME, ms_since_epoch, TPSMEMBERLEVEL ) encrypted_obj = enc_obj.encrypt( plaintext_token ) encoded_obj = base64.b64encode( bytes( encrypted_obj ) ) urlencoded_obj = urllib.quote_plus( encoded_obj ) return urlencoded_obj
def triple_des_decryption_module(key_data,config_data): try: des_decryption = triple_des(key_data) decrypted_data = des_decryption.decrypt(config_data) return decrypted_data except Exception as e: print e pass
def decrypt(ciph): import pyDes, iPXSettings from binascii import unhexlify ciph = unhexlify(ciph) key = iPXSettings.getVar('3DESKey') key = key.decode('rot-13') k = pyDes.triple_des(key) d = k.decrypt(ciph, ' ') return d
def generate_mac(data, key, iv, flip_key=False): # Data is first split into tuples of 8 character bytes, each # tuple then reversed and joined, finally all joined back to # one string that is then triple des encrypted with key and # initialization vector iv. If flip_key is True then the key # halfs will be exchanged (this is used to generate a mac for # write). The resulting mac is the last 8 bytes returned in # reversed order. assert len(data) % 8 == 0 and len(key) == 16 and len(iv) == 8 key = bytes(key[8:] + key[:8]) if flip_key else bytes(key) txt = [''.join(reversed(x)) for x in zip(*[iter(bytes(data))]*8)] return triple_des(key, CBC, bytes(iv)).encrypt(''.join(txt))[:-9:-1]
def calc_mid_key(key,seed): dk = pyDes.triple_des(codecs.decode(key,'hex'), pad=None, padmode=pyDes.PAD_NORMAL) e1 = codecs.decode(seed,'hex') e2 = '' for i in range(len(e1)): e2 = e2 + chr((~ord(e1[i])) & 0xFF) ed1 = dk.encrypt(e1) ed2 = dk.encrypt(e2) s = codecs.encode(ed1+ed2,'hex') return s
def __EncriptData(data, loginKey, iv): import pyDes, array #Encript with tripleDES in CBC mode and with '\0' as padding loginKeyAsString = str(loginKey) ivAsString = str(iv) des = pyDes.triple_des(loginKeyAsString, pyDes.CBC, ivAsString, pad= '\0', padmode = pyDes.PAD_NORMAL) dataAsString = ''.join([chr(c) for c in data]) encriptedData = des.encrypt(dataAsString); return array.array("B", encriptedData).tolist()
def encrypt(data, pinid): key = get_wxlt_config(pinid).get('des_key') if key: if len(key) < 24: key += ' ' * (24 - len(key)) if len(key) > 24: key = key[:24] vi = '12345678' k = triple_des(key, CBC, vi, pad=None, padmode=PAD_PKCS5) d = k.encrypt(data) rst = b64encode(d) else: rst = data return rst
def pydes_encrypt(plain_text, password): hashed_pw = hash_password(password) cipher_text = triple_des(hashed_pw).encrypt(plain_text, padmode=2) return cipher_text
def encrypt(buf, key): """This function will encrypt buffer using key using 3DES""" encrypter = pyDes.triple_des(key, pad=None, padmode=pyDes.PAD_PKCS5) buf = encrypter.encrypt(buf, pad=None, padmode=pyDes.PAD_PKCS5) return buf
def encrypt(self, value): value = str(value) _md5 = hashlib.md5() _md5.update(self.hash_key) k = triple_des(_md5.digest(), ECB, padmode=PAD_PKCS5) return k.encrypt(value).encode("base64").rstrip()
def decrypt(loader, node): return pyDes.triple_des(KEY, padmode=pyDes.PAD_PKCS5).decrypt( base64.b64decode(node.value))
def __init__(self,key): self.en_key = key #self.en_key = '138152311337088112957278' self._3DES = pyDes.triple_des(self.en_key, pyDes.ECB,b"\0\0\0\0\0\0\0\0", pad = '\0', padmode = pyDes.PAD_NORMAL)
sock_kdc = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock_kdc.connect((IP, PORT_KDC)) # 3. Forward request to KDC (N1, Alice -> Bob, [Kbob_Nb]) N1 = helper.get_nonce(Alice_key) N1s = helper.nonce_num_to_str(N1) send = '{0}{1}{2}{3}'.format(N1s, Alice_ID, Bob_ID, Kbob_Nb if EXTENDED else '') print 'Alice: Requesting to KDC' helper.sock_safe_send(sock_kdc, send, sock_bob) # 4. Get response from KDC print 'Alice: Getting response from KDC' recv = helper.sock_safe_recv(sock_kdc, sock_bob) sock_kdc.close() # Done with KDC recv = pyDes.triple_des(Alice_key, DES_MODE).decrypt(recv) # Error checking size = 80 if EXTENDED else 72 if len(recv) != size: helper.shutdown(sock_bob, msg='Alice: KDC message size mismatch') if recv[:8] != N1s or recv[8:16] != Bob_ID: helper.shutdown(sock_bob, msg='Alice: KDC validation failed') Kab = recv[16:40] ticket_to_Bob = recv[40:] # 5. Send ticket to Bob N2 = helper.get_nonce(Alice_key) N2s = helper.nonce_num_to_str(N2) send = '{0}{1}'.format(ticket_to_Bob,
def verify_internal_authN(self, msg, rand): """ Virifies the response received from the Internal AuthN command. In the process, it updates the value of self.NT, self.TK and self.SK. @param msg: hex string Response message from the SmartCard. Its length must be 10 Bytes (20 hex characters) @param rand: hex string Random number sent to the SmartCard @return: int -3 the verification failed -2 error calculating the keys -1 the length of the msg or rand parameters was incorrect 0 if the operation finished without any warning > 1, indicating the number of non-critical warnings """ ret_val = 0 # We're going to work with binary from now on msg = binascii.unhexlify(msg) rand = binascii.unhexlify(rand) # The message has to be 10 Bytes long # The random number, 8 Bytes if (len(msg) != 10) or (len(rand) != 8): print( "ERROR: Either the message '{:s}' or the random number '{:s}' don't " "have the correct length.".format( binascii.hexlify(msg).decode("utf-8"), binascii.hexlify(rand).decode("utf-8"))) return -1 nt = int.from_bytes(msg[:2], byteorder="big") signature = msg[2:] # If available, checks the NT counter if not self.NT: self.NT = (nt - 2) if self.NT != (nt - 2): print( "WARNING: the received value of NT '{:d}' doesn't match with " "the predicted one '{:d}'".format(nt, self.NT + 2)) ret_val = ret_val + 1 # Calculates the Session Key # It may fail for multiple reasons, so it's wise to do it before making further # changes in the internal state of the object if not self.derive_session_key(self.NT): print("ERROR: Couldn't derive session key") return -1 # ---------- # Keys derived and all checks done -> starts the verification print("Derived keys:\n\tTemporal -> {:s}\n\tSession -> {:s}".format( binascii.hexlify(self.TK).decode("utf-8"), binascii.hexlify(self.SK).decode("utf-8"))) # 3DES (TK, rand) == msg calc_signature = pyDes.triple_des(self.TK).encrypt(rand) if calc_signature != signature: print("ERROR: Verification failed. Should be '{:s}', " "but was '{:s}'".format( binascii.hexlify(calc_signature).decode("utf-8"), binascii.hexlify(signature).decode("utf-8"))) ret_val = -3 # return -3 # --------------- # Everything finished -> the state can be changed self.NT = self.NT + 2 return ret_val
import pyDes # pyDes.des(key, [mode], [IV], [pad], [padmode]) # pyDes.triple_des(key, [mode], [IV], [pad], [padmode]) # key -> Bytes containing the encryption key. 8 bytes for DES, 16 or 24 bytes # for Triple DES # mode -> Optional argument for encryption type, can be either # pyDes.ECB (Electronic Code Book) or pyDes.CBC (Cypher Block Chaining) # IV -> Optional Initial Value bytes, must be supplied if using CBC mode. # Length must be 8 bytes. # pad -> Optional argument, set the pad character (PAD_NORMAL) to use during # all encrypt/decrpt operations done with this instance. # padmode -> Optional argument, set the padding mode (PAD_NORMAL or PAD_PKCS5) # to use during all encrypt/decrypt operations done with this instance. key = 'frJ0gfKGc0ui6CQSYh3ZRamK' data = 'my name is zhouxw' k = pyDes.triple_des(key, pad=None, padmode=pyDes.PAD_PKCS5) value = k.encrypt(data=bytes(data, 'utf-8')) print('value:', value) print('value:', value.hex().upper()) redata = k.decrypt(value) print('redata:', redata.decode()) hexvalue = '9332FCE3E3678A7181176DCF249AF5F5D2A4E763480C0BBC7F78C5DEEFB6B7AD' value = k.decrypt(bytes.fromhex(hexvalue)) print('解密值:', value.decode())
def pydes_decrypt(cipher_text, password): hashed_pw = hash_password(password) plain_text = triple_des(hashed_pw).decrypt(cipher_text, padmode=2) return plain_text
def _encrypte(self, text): singer = triple_des(key=base64.b64decode(self.terminal_key), padmode=PAD_PKCS5) sign_data = singer.encrypt(text) return base64.b64encode(sign_data)
def tripledesencrypt(key, data): k = pyDes.triple_des(key, pad=None, padmode=pyDes.PAD_NORMAL) return k.encrypt(data)
def encrypt_message(message: str, cypher: int): return pyDes.triple_des(str(cypher).ljust(24)).encrypt(message.encode(encoding), padmode=2).hex()
def des3_encrypt(key, ivect, text): cipher = triple_des(key, mode=pyDes.CBC, IV=ivect, padmode=pyDes.PAD_PKCS5) r = cipher.encrypt(text) return base64.standard_b64encode(r)
def decrypt(self, value): value = b64decode(value) _md5 = hashlib.md5() _md5.update(self.hash_key) k = triple_des(_md5.digest(), ECB, padmode=PAD_PKCS5) return k.decrypt(value)
def encode_log_location(group, stream, reqid): val = json.dumps([group, stream, reqid]) enc = pyDes.triple_des(short_token()).encrypt(val, padmode=pyDes.PAD_PKCS5) return base64.encodestring(enc)
#!/usr/bin/env python import os import pyDes from secret import FLAG, KEY d1 = pyDes.des(KEY) ciphertext1 = d1.encrypt(os.urandom(8)).encode('base64') d2 = pyDes.triple_des(KEY * 3) ciphertext2 = d2.encrypt(FLAG.encode()).encode('base64') with open('ciphertext', 'wb') as f: f.write('ciphertext1 = ' + ciphertext1) f.write('ciphertext2 = ' + ciphertext2) print d1.Kn[6] # [1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0]
def decrypt(self, data): k = pyDes.triple_des(self.key, pyDes.ECB, self.iv, pad=None, padmode=pyDes.PAD_PKCS5) data = base64.decodestring(data) d = k.decrypt(data) return d
def tdes_cbc_enc(key, data, iv=DEFAULT_IV, pad=PAD_NONE) -> bytes: data = _add_padding(data, pad) tdes = pyDes.triple_des(key, mode=pyDes.CBC, IV=iv) return tdes.encrypt(data)
payPassword = '' sIV = "hellocxp" def UPPER_MD5(value): return helper.md5(value).upper() md5Password = UPPER_MD5(password) # print 'UPPER_MD5为%s' % md5Password # 会话秘钥 sha256key = key + md5Password KEY = hashlib.sha256(sha256key.encode('utf-8')) KEY = KEY.digest() KEY = KEY[0:24] # KEY = str(KEY2) # 密钥 IV = sIV # 偏转向量 desObj = pyDes.triple_des(KEY, ECB, IV, pad=None, padmode=PAD_PKCS5) # 使用DES对称加密算法的CBC模式加密 str = desObj.encrypt(UPPER_MD5(payPassword)) print base64.b64encode(str) print res
def tdes_cbc_dec(key, data, iv=DEFAULT_IV, pad=PAD_NONE) -> bytes: tdes = pyDes.triple_des(key, mode=pyDes.CBC, IV=iv) ret = tdes.decrypt(data) return _rm_padding(ret, pad)
def encrypt_text(text, key): cipher = pyDes.triple_des(b"{}".format(key), pyDes.ECB, padmode=pyDes.PAD_PKCS5) encrypted_text = cipher.encrypt(b"{}".format(text)) return base64.b64encode(encrypted_text)
def tdes_ecb_enc(key, data, pad=PAD_NONE) -> bytes: data = _add_padding(data, pad) tdes = pyDes.triple_des(key, mode=pyDes.ECB) return tdes.encrypt(data)
def encrypt(value): print base64.b64encode( pyDes.triple_des(KEY, padmode=pyDes.PAD_PKCS5).encrypt(value))
def decrypt(cipher, key): """This function will decrypt cipher using 3des from key""" decrypter = pyDes.triple_des(key, pad=None, padmode=pyDes.PAD_PKCS5) buf = decrypter.decrypt(cipher, pad=None, padmode=pyDes.PAD_PKCS5) return buf
def triple_desencrypt(key,data): k = pyDes.triple_des(codecs.decode(key,'hex'),pad=None, padmode=pyDes.PAD_NORMAL) e1 = k.encrypt(codecs.decode(data,'hex')) return codecs.encode(e1,'hex')
def get_des(k): k = get_key(k) return pyDes.triple_des(k, padmode=pyDes.PAD_PKCS5)
# -*- coding: utf-8 -*- import sys import csv from pyDes import CBC, PAD_PKCS5, triple_des if __name__ == "__main__": if len(sys.argv) < 3: print u'缺少参数,需要输入csv文件名和密钥,如:python generate_license.py license.csv cn=hunan,c=cn' sys.exit(1) csv_file = sys.argv[1] des_key = sys.argv[2] suffix = des_key.split(",")[0].split("=")[-1] reader = csv.reader(open(csv_file,'rb')) data = [] for row in reader: data.append("=".join([value.decode('gbk') for value in row])) data = ",".join(data) if len(des_key) < 16: des_key += '\0'*(16-len(des_key)) else: des_key = des_key[0:16] k = triple_des(des_key, CBC, "opengoss",pad=None, padmode=PAD_PKCS5) en_data = k.encrypt(data.encode('utf8')) with open("LICENSE."+ suffix, 'wb') as file: file.write(en_data) #de_data = k.decrypt(en_data) #for data in de_data.split(","): # print data.split("=")[1]
def decode_log_location(base64id): dec = base64.decodestring(base64id) unencrypted = pyDes.triple_des(short_token()).decrypt( dec, padmode=pyDes.PAD_PKCS5) inflated = json.loads(unencrypted) return inflated
def MAC(self): mab = self.format_data() key = bytes.fromhex(self.MACKey()) k = pyDes.triple_des(key, pyDes.CBC, b'\0\0\0\0\0\0\0\0', 0) res = k.encrypt(mab) return binascii.hexlify(res[-8:]).upper().decode()
# get the DES KEY and IV IVPtr = dump.readPtrWithOffset(keyPos[0] + IVOffset) #getIVPtr dump.move(IVPtr) IV = dump.readRaw(IVLength) DESKeyPtr = dump.readPtrWithOffset(keyPos[0] + DESKeyPtrOffset) DESKeyPtr = dump.readPtr(DESKeyPtr) dump.move(DESKeyPtr) KBHK = KIWI_BCRYPT_HANDLE_KEY(dump) dump.move(KBHK.ptrKey.value) KBK = KBHK.ptrKey.read(dump, KIWI_BCRYPT_KEY81) desKey = KBK.hardkey.data # In[59]: # decrypted the passWd k = triple_des(desKey, CBC, IV[:8]) plainTxt = k.decrypt(encPasswd) plainTxt = str(hexlify(plainTxt)) # In[60]: NT = plainTxt[150:182] SHA1 = plainTxt[214:254] print("userName:"******"domainName:", firstSess.domainName.readString(dump)) print("NT:", NT) print("SHA1:", SHA1)
def TesteCrypto(Input, Tipo): #os.system("cls") StringOut = Input #Mensagem = str(raw_input('Informe uma mensagem: ')) Senha = '1234567894532112' if Tipo.upper() == 'E': try: StringOut = pyDes.triple_des(Senha).encrypt(Input, padmode=2) StringOut = str(StringOut).replace("'","'+char(39)+'") except: pass elif Tipo.upper() == 'D': try: StringOut = pyDes.triple_des(Senha).decrypt(Input, padmode=2) except: pass else: return 'Nenhuma opcao valida informada!' #print 'Mensagem Cryptografada: "' + ciphertext +'"' #print 'Mensagem sem Cryptografia: "'+ plain_text + '"' return StringOut