def generateMAC(message, key):
padding = ""
endblock = ""
(K1, K2) = generateSubkeys(key, "\x00\x00\x00\x00\x00\x00\x00\x1b")
#print K1.encode("hex")
#print K2.encode("hex")
if len(message) % 8:
padLen = 8 - (len(message) % 8)
padding = "\x80" + ("\x00" * (padLen - 1))
message = message + padding
endblock = message[-8:len(message)]
XORencryptor = XOR.XORCipher(K2)
endblock = XORencryptor.encrypt(endblock)
else:
endblock = message[-8:len(message)]
XORencryptor = XOR.XORCipher(K1)
endblock = XORencryptor.encrypt(endblock)
message = message[0:-8] + endblock
CMACencryptor = DES3.new(key, DES3.MODE_CBC,
'\x00\x00\x00\x00\x00\x00\x00\x00')
mac = CMACencryptor.encrypt(message)
#print key.encode("hex")
#print message.encode("hex")
#print mac.encode("hex")
#return mac
return mac[-8:len(mac)]
def encrypt_url(path, dl_filename=None):
"""
Call this within your client app to generate a URL to query the
Cryptostream WSGI app server with.
path: (str) The URL path to the internal-flagged location
on the Nginx server that the files will be served from via
X-Accel-Redirect.
dl_filename: (str/None) If specified, the file that the user downloads will
be named according to the value, instead of from the name on
the filesystem.
"""
# Encrypt the path and the timestamp.
path = XOR.new(KEY).encrypt(path)
ts = XOR.new(KEY).encrypt(time.time().__str__())
# Encode path/ts to base 64.
path = base64.b64encode(path)
ts = base64.b64encode(ts)
# This dict will get urlencoded as GET keywords.
value_dict = {"path": path, "ts": ts}
# Check for download filename override.
if dl_filename:
value_dict["dl_filename"] = dl_filename
return urllib.urlencode(value_dict)
def initvars():
global Logueado
Logueado = False
config = ConfigParser()
config.read("conf/config.ini")
tipo = config.get('CUENTA', 'Tipo')
ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
xorps = XOR.new(str(ps))
global Tipo
Tipo = xorps.decrypt(b64decode(str(tipo)))
webserver = config.get('WEB', 'srv')
ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
xorps = XOR.new(str(ps))
global WEBServer
WEBServer = xorps.decrypt(b64decode(str(webserver)))
print WEBServer
global DatosUsuario
DatosUsuario = {}
global DictSenales
DictSenales = {}
global BD
BD = BasedeDatos()
BD.Conectar()
global DictColaResultados
DictColaResultados = {}
t = threading.Thread(target=GetIps)
t.start()
def initvars():
global Logueado
Logueado = False
config = ConfigParser()
config.read("conf/config.ini")
tipo = config.get('CUENTA', 'Tipo')
ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
xorps = XOR.new(str(ps))
global Tipo
Tipo = xorps.decrypt(b64decode(str(tipo)))
webserver = config.get('WEB', 'srv')
ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
xorps = XOR.new(str(ps))
global WEBServer
WEBServer = xorps.decrypt(b64decode(str(webserver)))
print WEBServer
global DatosUsuario
DatosUsuario = {}
global DictSenales
DictSenales = {}
global BD
BD = BasedeDatos()
BD.Conectar()
global DictColaResultados
DictColaResultados = {}
t = threading.Thread(target=GetIps)
t.start()
def encrypt(hstr, payload, encryptionKey):
hstr = XOR.new(encryptionKey).encrypt(hstr)
hstr = base64.b64encode(hstr)
payload = XOR.new(encryptionKey).encrypt(payload)
payload = base64.b64encode(payload)
return [hstr, payload]
def xor_encode_dict(dictionary):
""" Кодирует словарь алгоритмом XOR """
result = {}
for key, val in dictionary.iteritems():
key = base64.encodestring(XOR.new(settings.XOR_KEY).encrypt(key))
val = base64.encodestring(XOR.new(settings.XOR_KEY).encrypt(val))
result[key] = val
return result
def main(): key = b"The secret key" # Encryption encryption_suite = XOR.new(key) cipher_text = encryption_suite.encrypt(b"Hello world!") print(cipher_text) # Decryption decryption_suite = XOR.new(key) plain_text = decryption_suite.decrypt(cipher_text) print(plain_text)
def _getMAC(self, mac, key):
modName = self.macMap[mac]
if not modName:
return None
mod = __import__(modName, {}, {}, '')
if not hasattr(mod, 'digest_size'):
ds = len(mod.new().digest())
else:
ds = mod.digest_size
key = key[: ds]+'\x00'*(64-ds)
i = XOR.new('\x36').encrypt(key)
o = XOR.new('\x5c').encrypt(key)
return mod, i,o, ds
def _getMAC(self, mac, key):
modName = self.macMap[mac]
if not modName:
return None
mod = __import__(modName, {}, {}, '')
if not hasattr(mod, 'digest_size'):
ds = len(mod.new().digest())
else:
ds = mod.digest_size
key = key[:ds] + '\x00' * (64 - ds)
i = XOR.new('\x36').encrypt(key)
o = XOR.new('\x5c').encrypt(key)
return mod, i, o, ds
def app(environ, start_response):
"""
WSGI app method. You'll want to point your WSGI server at this method.
"""
data = environ["PATH_INFO"]
# GET querystring.
qs = urlparse.parse_qs(environ["QUERY_STRING"])
# Decode from base64.
try:
path = base64.b64decode(qs["path"][0])
ts = base64.b64decode(qs["ts"][0])
except:
return render_error_page(environ, start_response)
# Decrypt using XOR.
try:
path = XOR.new(KEY).decrypt(path)
ts = datetime.datetime.fromtimestamp(float(XOR.new(KEY).decrypt(ts)))
except:
return render_error_page(environ, start_response)
# Determine what the file will be named for the user's browser.
if qs.has_key("dl_filename"):
# Filename was passed as a GET keyword.
dl_filename = qs["dl_filename"][0]
else:
# No filename specified, use the name on the filesystem.
dl_filename = os.path.basename(path)
dbg = path
now = datetime.datetime.now()
if (now - ts) > LINK_EXPIRE_TDELTA:
# Expired, show vague error page.
return render_error_page(environ, start_response)
else:
# Everything is good, serve the file through X-Accel-Redirect.
status = "200 OK"
response_headers = [
("X-Accel-Redirect", path),
("Content-Disposition", "attachment; filename=%s" % dl_filename),
]
start_response(status, response_headers)
# This needs to be an empty string or we'll get premature socket
# closing errors. The body is ignored by Nginx, and the connection is
# closed before this returned value can be read, causing the error.
return ""
def encrypt(self, timerPrinting=False):
"""To give the Order To Encrypt The File"""
t = time.time()
#Check If The File is
if self.extension not in self.path:
with open(self.path, 'rb') as file:
file_data = file.read()
#Start To CHecking The PlatForm
# if platform.system() == "Windows":
# self.path_dir = self.path.split("\\")[-1]
# elif platform.system() == "Linux":
# self.path_dir = self.path.split('/')[-1]
# #End Checking Wich Platform
# print('Encryption of '+self.path_dir+'...')
# print('It\'s may take a will')
######################### XOR Algorithm #########################
cipher = XOR.new(self.key)
self.encoded = base64.b64encode(cipher.encrypt(file_data))
#################################################################
#print('writing in you file ...')
os.remove(self.path)
with open(str(self.path) + self.extension, "wb") as outfile:
outfile.write(self.encoded)
if timerPrinting:
print('Done In ' + str(time.time() - t))
else:
pass
else:
print("The File is already encrypt")
def initiate_session(self):
# Perform the initial connection handshake for agreeing on a shared secret
### TODO: Your code here!
# This can be broken into code run just on the server or just on the client
if self.server or self.client:
my_public_key, my_private_key = create_dh_key()
# Send them our public key
self.send(bytes(str(my_public_key), "ascii"))
# Receive their public key
their_public_key = int(self.recv())
# Obtain our shared secret
shared_hash = calculate_dh_secret(their_public_key, my_private_key, key_len=64)
print("Shared session key: {}".format(binascii.hexlify(shared_hash)))
# The first 256 bit from shared hash is the key of hmac
self.hmac = HMAC.new(shared_hash[:32], digestmod=SHA256)
# TODO: exchange iv
# TODO: use a global bloom filter to avoid iv re-use in a reasonable time period,
# and we can add a time stamp after iv to avoid replay if the iv filter is reset
# The last 256 bit from shared hash is the key of hmac
cipher_key = shared_hash[:-32]
# TODO: init cipher with aes-cfb using cipher_key and iv
# Default XOR algorithm can only take a key of length 32
self.cipher = XOR.new(shared_hash[:4])
def get_key(request):
if (request.method != 'POST'):
return err_GE002()
form = GetKeyForm(request.POST)
if (not form.is_valid()):
return err_GE031(form)
#dbkey = get_user_key(request, ss=form.cleaned_data['secret'])
db_secret = request.device_assn.db_secret
xor = XOR.new(base64.b64decode(form.cleaned_data['secret']))
db_key = xor.encrypt(base64.b64decode(db_secret))
if (not request.device_assn.verify_db_key(db_key)):
return err_GE022()
# Okay, we need to test the validity of this key before we return it.
# Otherwise, we could return an invalid key.
response = {
'data': {
'key':base64.b64encode(db_key),
# 'gcm_project_id': settings.GCM_PROJECT_ID
},
'warnings':{}
}
return HttpResponse(content=json.dumps(response), mimetype='application/json')
def encrypt(self, key, plaintext):
(input_whitening_key, output_whitening_key) = self.build_whitening_keys(key)
input_whitener = XOR.new(str(input_whitening_key)).encrypt
output_whitener = XOR.new(str(output_whitening_key)).encrypt
ciphertext = bytearray(len(plaintext))
if (len(plaintext) % 8):
raise Exception("plaintext length must be a multiple of 8")
des = DES.new(str(key[0:8]), DES.MODE_CBC, str(bytearray(8))).encrypt
for i in range(len(plaintext)/8):
ciphertext[i*8:i*8+8] = bytearray(output_whitener(des(input_whitener(str(plaintext[i*8:i*8+8])))))
des = DES.new(str(key[0:8]), DES.MODE_CBC, str(bytearray(8))).encrypt
return ciphertext
def xor_decrypt(raw):
if cipher[0] is None:
if len(raw) < AES.block_size:
return None, 0
cipher[0] = XOR.new(raw[: AES.block_size])
return None, AES.block_size
return cipher[0].decrypt(raw), len(raw)
def decifra():
mensagem = raw_input("Digite aqui a mensagem a ser decifrada: ")
mensagem1 = mensagem.decode('hex')
senha = raw_input("Digite a senha: ")
xor2 = XOR.new(senha)
mensagem_decifrada = xor2.decrypt(mensagem1)
print mensagem_decifrada
def ObtenerConexion(self):
config = ConfigParser()
config.read("conf/config.ini")
self.conexion = config.get('REMOTE', 'conexion')
ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
xorps = XOR.new(str(ps))
self.conexion = xorps.decrypt(b64decode(str(self.conexion)))
def try_to_find_config(
data_provider,
mode=SearchMode.ALL,
hint_key=None,
):
""" try all the XOR magic to find data looking like config """
if mode in (SearchMode.PACKED, SearchMode.ALL):
logger.debug("MODE == PACKED")
keys_to_test = range(0xff) if hint_key is None else [hint_key]
for cur_key in keys_to_test:
logger.debug(f"TESTING KEY = {cur_key}")
_xor_array_fn = lambda arr, key=cur_key: XOR.new(bytes([key])
).encrypt(arr)
finder = AlmostLikeYara(CobaltCommons.PACKED_CONFIG_PATTERN,
encoder=_xor_array_fn)
result = data_provider.find_using_func(finder.smart_search)
if result != NOT_FOUND:
data_provider.set_encoder(_xor_array_fn)
logger.debug(f"Found config @ 0x{result:08X} , key={cur_key}")
return data_provider, SearchMode.PACKED
if mode in (SearchMode.UNPACKED, SearchMode.ALL):
logger.debug("MOD == UNPACKED")
finder = AlmostLikeYara(CobaltCommons.UNPACKED_CONFIG_PATTERN)
result = data_provider.find_using_func(finder.smart_search)
if result != NOT_FOUND:
logger.debug(f"Found config @ {result}")
return data_provider, SearchMode.UNPACKED
return None
def derive_transform_iv(src_blk, dst_blk, key):
# Determine the IV required to encrypt `src_blk` to `dst_blk` using
# AES-128-CBC with `key`. Assumes src_blk and dst_blk are one block
# in size (128 bits/16 bytes)
cipher = AES.new(key, AES.MODE_CBC, '\0' * AES_BLOCK_SIZE)
dec = cipher.decrypt(dst_blk)
return XOR.new(src_blk).encrypt(dec)
def decrypt(self, timerPrinting=False):
t = time.time()
"""To Give The Order To Decrypt The File"""
if self.extension in self.path:
with open(self.path, 'rb') as file:
file_data = file.read()
#Start To CHecking The PlatForm
# if platform.system() == "Windows":
# self.path = self.path.split("\\")[-1]
# elif platform.system() == "Linux":
# self.path = self.path.split('/')[-1]
# End Checking Wich Platform
# print("Decrypting of "+str(self.path)+"...")
############################################################################
cipher = XOR.new(self.key)
self.decoded = cipher.decrypt(base64.b64decode(file_data))
############################################################################
self.path2 = self.path.replace(self.extension, "")
os.remove(self.path)
# print('Writing in Your File...')
with open(self.path2, 'wb') as outfile:
outfile.write(self.decoded)
if timerPrinting:
print('Done In ' + str(time.time() - t))
else:
pass
else:
print("The File is Not Encrypted To Decrypted")
def InsertarBDRemote(self):
print 'No existe cliente insertando'
self.IPPublica = '0'
try:
self.IPPublica = urlopen('http://ip.42.pl/raw').read().encode('utf8')
except:
pass
nameempresa = 'Desconocido'
try:
config = ConfigParser()
config.read("conf/config.ini")
string = config.get('BASE DE DATOS', 'conexion')
ps = b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
xorps = XOR.new(str(ps))
string = xorps.decrypt(b64decode(str(string)))
self.cnxn1 = pyodbc.connect(string)
self.cursor1 = self.cnxn1.cursor()
self.cursor1.execute("SELECT nombre FROM t365_Empresas WHERE master = 1")
rows = self.cursor1.fetchall()
if rows:
nameempresa = rows[0].nombre
self.cursor.execute("INSERT INTO [t365_Valid] ([namempresa],[mac],[namepc],[ip]) VALUES (?,?,?,?)",nameempresa,str(':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff) for i in range(0,8*6,8)][::-1])),gethostname(),self.IPPublica)
self.cnxn.commit()
except:
pass
async def xorencrypt(self, ctx, data, key):
"""Uses XOR to encipher the given text with the given key."""
encryption = XOR.new(key)
encrypted_data = base64.b64encode(
encryption.encrypt(data)).decode('utf-8')
await ctx.send(
f':white_check_mark: **Encrypted data**: {encrypted_data}')
def decrypt_list(proc_list, key):
plain_list = []
cipher = XOR.new(key)
for ciphertext in proc_list[:-3]:
if ciphertext:
plain_list.append(cipher.decrypt(base64.b64decode(ciphertext)))
return plain_list
def encrypt_file(filename, key):
key = get_hashed_key(key.encode('utf-8'))
try:
file_handler = open(filename, 'rb')
out_filename = filename + '.enc'
out_file_handler = open(out_filename, 'wb')
symmetric_key = XOR.new(key)
while True:
chunk = file_handler.read(1)
if chunk:
cipher_text = symmetric_key.encrypt(chunk)
out_file_handler.write(cipher_text)
else:
break
file_handler.close()
out_file_handler.close()
except FileNotFoundError:
print('A file with this name could not be found !')
exit(1)
def decrypt(self, data):
if len(data) % 16 != 0:
raise ValueError(
"Input strings must be a multiple of 16 in length")
result = b''
x = self.iv[16:32]
y = self.iv[0:16]
for i in range((len(data) - 1) // 16 + 1):
input_block = data[i * 16:(i + 1) * 16]
output_block = XOR.new(x).decrypt(input_block)
output_block = self.aes.decrypt(output_block)
output_block = XOR.new(y).decrypt(output_block)
result += output_block
x = output_block
y = input_block
return result
def decrypt_chunk(secret, fpath, queue):
"""
@type secret: str
@type fpath: str
@type queue: multiprocessing.Queue
"""
chunk_file = open(fpath.strip())
chunk_pos_len = int(chunk_file.readline())
chunk_pos = int(chunk_file.read(chunk_pos_len))
initialization_vector_len = int(chunk_file.readline())
initialization_vector = chunk_file.read(initialization_vector_len)
data_hash_len = int(chunk_file.readline())
data_hash = chunk_file.read(data_hash_len)
enc_data_len = int(chunk_file.readline())
enc_data = chunk_file.read(enc_data_len)
if 16 != len(initialization_vector):
raise Exception("initialization_vector len is not 16")
#cipher = AES.new(secret, AES.MODE_CFB, IV=initialization_vector)
cipher = XOR.new(secret)
dec_data = cipher.decrypt(enc_data)
calculated_hash = make_checksum(dec_data)
if data_hash != calculated_hash:
raise EncryptionHashMismatch("decrypt_file -> the decryption went wrong, hash didn't match")
if queue.qsize() > 20:
time.sleep(0.5)
queue.put((chunk_pos, dec_data))
return True
def decrypt_file(filename, key):
key = get_hashed_key(key.encode('utf-8'))
if not filename[len(filename) - 4:] == '.enc':
print('Incorrect file extension : file must end in .enc')
exit(1)
try:
file_handler = open(filename, 'rb')
out_filename = 'DEC_' + filename[:-4]
out_file_handler = open(out_filename, 'wb')
symmetric_key = XOR.new(key)
while True:
chunk = file_handler.read(1)
if chunk:
plain_text = symmetric_key.decrypt(chunk)
out_file_handler.write(plain_text)
else:
break
file_handler.close()
out_file_handler.close()
except FileNotFoundError:
print('A file with this name could not be found !')
def decryptCTR(self, ctext):
print()
iv = ctext[:2*AES.block_size]
# print('iv:', iv)
c = ctext[2*AES.block_size:]
self.count = '0x' + iv
cipher = AES.new(self.key,AES.MODE_ECB)
bmsg=[]
numBlocks = int(len(c)//(2*AES.block_size))
if len(c)%AES.block_size!=0:
numBlocks+=1
# print('numBlocks:', numBlocks)
msg=''
for i in range(numBlocks):
if i!=numBlocks:
hexDigits = 2*AES.block_size
else: hexDigits = len(c)%(2*AES.block_size)
E = cipher.encrypt(bytes.fromhex(self.count[2:]))
# print('E:', E.hex())
ct = c[AES.block_size*i:AES.block_size*i+hexDigits]
# print('ct:', ct)
# block=xorb(ct, E)
xor = XOR.new(bytes.fromhex(ct))
block = xor.decrypt(E)
bmsg.append(block)
# print('block:', block.hex())
# print("block: ", block)
# blocktext = bytes.fromhex(block)
# print('blocktext:', blocktext)
for byte in msg:
# letter = chr(byte)
# print('ltr:', letter)
msg +=byte.decode()
self.incCounter()
return msg
def generateSubkeys(MACKey, constant):
#create encrptor
encryptor = DES3.new(MACKey, DES3.MODE_ECB,
'\x00\x00\x00\x00\x00\x00\x00\x00')
XORencryptor = XOR.XORCipher(constant)
K1 = ""
K2 = ""
zeros = "\x00" * 8 #8 bytes of zeros
S = encryptor.encrypt(zeros)
#print S.encode("hex")
if int(S[0].encode("hex"), 16) & 0x80:
shiftedS = "%016X" % (
(int(S.encode("hex"), 16) << 1) & 0xFFFFFFFFFFFFFFFF)
K1 = XORencryptor.encrypt(shiftedS.decode("hex"))
else:
shiftedS = "%016X" % (
(int(S.encode("hex"), 16) << 1) & 0xFFFFFFFFFFFFFFFF)
K1 = shiftedS.decode("hex")
if (int(K1[0].encode("hex"), 16) & 0x80):
#print K1.encode("hex")
shiftedS = "%016X" % (
(int(K1.encode("hex"), 16) << 1) & 0xFFFFFFFFFFFFFFFF)
K2 = XORencryptor.encrypt(shiftedS.decode("hex"))
else:
shiftedS = "%016X" % (
(int(K1.encode("hex"), 16) << 1) & 0xFFFFFFFFFFFFFFFF)
K2 = shiftedS.decode("hex")
return K1, K2
def encrypt_chunk(secret, fpath, chunksize, initialization_vector):
"""
@param secret: pkdf2 secre
@type secret: str
@type fpath: str
@type chunksize: tuple
"""
try:
f = open(fpath)
f.seek(chunksize[0])
chunk = f.read(chunksize[1])
#cipher = AES.new(secret, AES.MODE_CFB, IV=initialization_vector)
cipher = XOR.new(secret)
data_hash = make_checksum(chunk)
enc_data = cipher.encrypt(chunk)
ntf = get_named_temporary_file(auto_delete=False)
chunk_seek = str(chunksize[0])
ntf.write(str(len(chunk_seek)) + "\n")
ntf.write(chunk_seek)
ntf.write(str(len(initialization_vector)) + "\n")
ntf.write(initialization_vector)
ntf.write(str(len(data_hash)) + "\n")
ntf.write(data_hash)
ntf.write(str(len(enc_data)) + "\n")
ntf.write(enc_data)
return ntf.name
except Exception, e:
raise e
def createciphermsgs_xor(jt65msgcount, stegmsg, key, verbose=False):
# Performs the actual XOR cipher
ciphermsgs = []
# Can we fit your hidden message?
if jt65msgcount * 8 < len(stegmsg):
print(
"Length of hidden message exceeds capacity of number of valid JT65 messages provided")
sys.exit(0)
originallength = len(stegmsg)
while len(stegmsg) % 8:
stegmsg += chr(random.randint(0, 255))
cryptobj = XOR.new(key)
cipherdata = cryptobj.encrypt(stegmsg)
cipherlist = list(bytearray(cipherdata))
# Is the total length too big to fit into our max number of packets?
if len(cipherlist) > MAX_MULTI_PACKET_STEG_BYTES_XOR:
print("Length of hidden message exceeds capacity of multi-packet steg")
sys.exit(0)
totalpackets = len(cipherlist) / 8
if verbose:
print "Cipher list: " + str(cipherlist)
createciphermsgs_packer_xor(
totalpackets, originallength, ciphermsgs, cipherlist, verbose)
return ciphermsgs
async def xordecrypt(self, ctx, data, key):
"""Uses XOR to decipher the given text with the given key."""
encryption = XOR.new(key)
decrypted_data = encryption.decrypt(
base64.b64decode(data)).decode('utf-8')
await ctx.send(
f':white_check_mark: **Decrypted data**: {decrypted_data}')
def token_json(self, uuid):
crypt = XOR.new(self.password)
str = "%s\n%s " % ( int(time.mktime(datetime.now().timetuple())), uuid)
# I hate obfuscation. Its all I've got
token = crypt.encrypt(str)
return dict(token=urllib.quote(token),
prefered_protocol=self.smolt_protocol)
def __init__(self):
self.resultado = None
#Buscando el archivo INI para saber el String de Conexion
config = ConfigParser()
config.read("conf/config.ini")
self.conexioncifrada = config.get('BASE DE DATOS', 'conexion')
PASSWORD = XOR.new(base64.b64decode('MjAxMDE3MzMtOTYwOTkyNg=='))
self.conexion = PASSWORD.decrypt(base64.b64decode(str(self.conexioncifrada)))
def encrypt(key, plain_text):
"""
:param key: 36 byte 길이의 문자열. 나중에 암호를 푸는데 사용된다.
:param plain_text: 암호화하고 싶은 평문
:return: 암호화된 byte 타입 데이터
"""
cipher = XOR.new(key)
return base64.b64encode(cipher.encrypt(plain_text))
def xor(key, data):
if not isinstance(data, str):
raise RuntimeError("data value must be a string!")
if isinstance(key, (int, float)):
key = chr(key)
return XOR.new(key).decrypt(data)
def _xor(self, a, b):
"""Performs XOR on two strings a and b"""
if len(a) != len(b):
raise ValueError("ERROR: Strings are of different size! %s %s" % (len(a), len(b)))
xor = XOR.new(a)
return xor.encrypt(b)
def _xor(self, a, b):
"""Performs XOR on two strings a and b"""
if len(a) != len(b):
raise "ERROR: Strings are of different size! %s %s" % (len(a), len(b))
xor = XOR.new(a)
return xor.encrypt(b)
def __init__(self):
self.resultado = None
#Buscando el archivo INI para saber el String de Conexion
config = ConfigParser()
config.read("Conect.dat")
self.conexioncifrada = config.get('DB', 'StringDB')
PASSWORD = XOR.new(base64.b64decode('MjAxMDE3MzMtOTYwOTkyNg=='))
self.conexion = PASSWORD.decrypt(base64.b64decode(str(self.conexioncifrada)))
self.conexion = 'Driver={SQL Server Native Client 11.0};Server=AXNER-HP\JERMSOFT;Database=365DB_2;Uid=sa;Pwd=jerm'
def fixkey(key): half1= key[:16] half2= key[16:] encryptor = XOR.new(half2) newkey= encryptor.encrypt(half1) return newkey
def xorEncrypt(request):
plain_text = request.POST["message"]
output = u"Klartext:\n%s\n\n" %(plain_text)
key = hashlib.sha256(request.POST["key"]).digest()
output += u"Schlüssel: %s\n\n"%(request.POST["key"])
output += u"XOR-verschlüsselt:\n"
xorObject = XOR.new(key)
cypher = number.bytes_to_long(xorObject.encrypt(plain_text))
return ( output, cypher )
def _getMAC(self, mac, key):
"""
Gets a 4-tuple representing the message authentication code.
(<hash module>, <inner hash value>, <outer hash value>,
<digest size>)
@param mac: a key mapping into macMap
@type mac: C{str}
@param key: the MAC key.
@type key: C{str}
"""
mod = self.macMap[mac]
if not mod:
return (None, '', '', 0)
ds = mod().digest_size
key = key[:ds] + '\x00' * (64 - ds)
i = XOR.new('\x36').encrypt(key)
o = XOR.new('\x5c').encrypt(key)
return mod, i, o, ds
def check_admin_token(self, token, uuid):
print "TOKEN CHECK"
token = urllib.unquote(token)
crypt = XOR.new(self.password)
token_plain = crypt.decrypt(token).split('\n')
if uuid[:7] == token_plain[0]:
print 'GOT GOOD TOKEN!'
return token
else:
raise ValueError("Critical: %s not a valid token for UUID" % token)
def ConvertirDatos(stringbd,lic,cualmodo,dondebd):
print 'Convirtiendo Datos'
if dondebd == '1':
stringbd = stringbd.replace('NOMBREPC',str(gethostname()))
elif dondebd == '2':
print 'Indique la direccion donde se encuentra la Base de Datos'
direccionremota = raw_input('Indique una direccion IP o un DNS para la conexion a Base de Datos: ')
stringbd = stringbd.replace('NOMBREPC','mc24.no-ip.net')
stringbd = stringbd.replace('NOMBREBD','365DB')
stringbd = stringbd.replace('USUARIOBD','sa')
stringbd = stringbd.replace('PASSWORDBD','jerm')
deco = XOR.new(b64decode('MjAxMDE3MzMtOTYwOTkyNg=='))
stringbd = b64encode(deco.encrypt(str(stringbd)))
deco = XOR.new(b64decode('MjAxMDE3MzMtOTYwOTkyNg=='))
lic = b64encode(deco.encrypt(str(lic)))
deco = XOR.new(b64decode('MjAxMDE3MzMtOTYwOTkyNg=='))
cualmodo = b64encode(deco.encrypt(str(cualmodo)))
print 'Datos Convertidos'
CrearArchivo(stringbd,lic,cualmodo)
def check_token(self, token, uuid):
token = urllib.unquote(token)
crypt = XOR.new(self.password)
token_plain = crypt.decrypt(token).split('\n')
token_time = int(token_plain[0])
token_uuid = token_plain[1]
current_time = int(time.mktime(datetime.now().timetuple()))
if current_time - token_time > 60:
raise ValueError("Critical [20]: Invalid Token - Likely A timeout, please try again.")
if uuid.strip() != token_uuid.strip():
raise ValueError("Critical [s]: Invalid Token - Likely A timeout, please try again.")
def RKXencrypt(): plainText="Burning 'em, if you ain't quick and nimble\nI go crazy when I hear a cymbal" key = "ICE" cipherText = "" for x in range(0,len(plainText)): cipherText += util.b16encode(XOR.XORCipher.encrypt(XOR.new(key[x % 3]), plainText[x])) print cipherText if cipherText == "0b3637272a2b2e63622c2e69692a23693a2a3c6324202d623d63343c2a26226324272765272a282b2f20430a652e2c652a3124333a653e2b2027630c692b20283165286326302e27282f".upper(): print "Test Passed"
def gen_xor_encrypt():
init = [False]
key = Random.new().read(AES.block_size)
cipher = XOR.new(key)
def xor_encrypt(raw):
if init[0] is False:
init[0] = True
return key + cipher.encrypt(raw)
return cipher.encrypt(raw)
return xor_encrypt
def decryption(): print "Your key: " key = raw_input() print "Your encrypted password/message: " pw = raw_input() c = XOR.new(key) dpw = c.decrypt(base64.b64decode(pw)) print "Your decrypted password/message is: " + dpw print "Would you like to go again? (y/n)" an = raw_input() if an == 'y' or an == "Y": main()
def encryption(): print "Your key: (Remember this!) " key = raw_input() print "Your password/message: " pw = raw_input() c = XOR.new(key) epw = base64.b64encode(c.encrypt(pw)) print "Your encrypted password/message is: " + epw print "Would you like to go again? (y/n)" an = raw_input() if an == 'y' or an == "Y": main()
def __init__(self):
#Buscando el archivo INI para saber la configuracion del formato de numeros
self.config = ConfigParser()
self.config.read("conf/config.ini")
self.numsenc = self.config.get('MODEMS', 'nums')
self.Cipher = XOR.new(base64.b64decode('MjAxMDE3MzMtOTYwOTkyNg=='))
self.nums = self.Cipher.decrypt(base64.b64decode(str(self.numsenc)))
self.nums = self.nums.split(",")
self.dictnums = {}
letra = 0
for n in self.nums:
self.dictnums[str(string.lowercase[letra])]=n
letra = letra + 1
def xor_in_pi(text_bin):
flen = int(os.stat('pi.bin')[stat.ST_SIZE])
max_start = flen - len(text_bin)
some_pi = get_some_pi(max_start, qcrypt.normalize(text_bin))
xor = XOR.new(some_pi)
ciphertext = xor.encrypt(text_bin)
if debug:
print '\n------xor_in_pi------'
print qcrypt.normalize(text_bin)
print qcrypt.normalize(some_pi)
print qcrypt.normalize(ciphertext)
print '------xor_in_pi------\n'
return ciphertext
def admin_token_json(self, uuid):
from hardware.model import *
crypt = XOR.new(self.password)
try:
host_object = session.query(Host).filter_by(uuid=uuid).one()
except:
pass
#raise ValueError("Critical: UUID Not Found - %s" % uuid)
str = "%s" % (uuid[:7])
# I hate obfuscation. Its all I've got
token = crypt.encrypt(str)
return dict(token=urllib.quote(token),
prefered_protocol=self.smolt_protocol)
def LicCheckRemote():
config = ConfigParser()
config.read("conf/config.ini")
LicCif = config.get('CUENTA', 'Lic')
contrasena = base64.b64decode('MjAxMDE3MzMtOTYwOTkyNg==')
PASSWORD = XOR.new(str(contrasena))
try:
#Por si da algun error en la decodificacion
LicDecif = PASSWORD.decrypt(base64.b64decode(str(LicCif)))
except:
LicDecif = None
if str(xxmx) == str(LicDecif):
return True
else:
return False
def initiate_session(self):
# Perform the initial connection handshake for agreeing on a shared secret
### TODO: Your code here!
# This can be broken into code run just on the server or just on the client
if self.server or self.client:
my_public_key, my_private_key = create_dh_key()
# Send them our public key
self.send(bytes(str(my_public_key), "ascii"))
# Receive their public key
their_public_key = int(self.recv())
# Obtain our shared secret
shared_hash = calculate_dh_secret(their_public_key, my_private_key)
print("Shared hash: {}".format(shared_hash))
# Default XOR algorithm can only take a key of length 32
self.cipher = XOR.new(shared_hash[:4])
