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
