def main():
plain_text = "meet me after the toga party"
n = 8
N = 2**n
K = "hello world key"
k = 4 # Key size in bytes
secret_key = list(map(lambda x: ord(x), sample(K, k)))
initial_vector = sample(range(N), k)
# key = list(range(k)) # Key definition
key = secret_key + initial_vector # Key definition
# S-boxes definition
sbox = list(range(N))
sboxes = [sbox[:N // 2], sbox[N // 2:]]
# RC4 function call to encrypt
encrypt, key_stream = rc4(key, k, plain_text, N, sboxes)
# Show the encryption
showStatus("Encryption", plain_text, key, key_stream, encrypt)
# Reinitialize sboxes
sboxes = [sbox[:N // 2], sbox[N // 2:]]
# RC4 function call to decrypt
decrypt, key_stream = rc4(key, k, encrypt, N, sboxes)
# Show the decryption
showStatus("Decryption", encrypt, key, key_stream, decrypt)
def current_user(request):
account = request.META.get('HTTP_X_AC')
rid = request.META.get('HTTP_X_RID')
try:
if account:
account = base64.b64decode(account)
account = rc4.rc4(account, GAME_KEY)
user = User.objects.filter(account=account).first()
elif rid:
rid = base64.b64decode(rid)
rid = rc4.rc4(rid, GAME_KEY)
user = User.objects.filter(rid=rid).first()
else:
return jsonify(data=None,
success=False,
errMsg='Lack of user info.')
except:
return jsonify(data=None,
success=False,
errMsg='User info decode error.')
if not user:
return jsonify(data=None, success=False, errMsg="User is not logined.")
return user
def main():
K = [4, 7, 5, 5]
N = 8
cur_i = 4
z = 6
K = guess_keys(N, K, cur_i, z)
rc4(N, K)
def find_key6(ct):
text = ct[:20]
max_score = 0
max_score_key = ''
rating = 0
for i in range(start, end):
rating = (1 * count_printable(rc4.rc4(str(i), text))) + (
.75 * count_letters((rc4.rc4(str(i), text)))) + (englishy(
(rc4.rc4(str(i), text))))
if rating >= max_score:
max_score = rating
max_score_key = str(i)
return max_score_key
def decoder(self, pkt, keyText):
"""Take a packet with [Dot11WEP] and apply RC4 to get the [LLC]"""
## Re-use the IV for comparative purposes
# <class 'bytes'>
# b'z\x00\x00\x124Vx\x90'
# print('DECODING')
# print([pkt[Dot11WEP].iv])
# print(str([pkt[Dot11WEP].iv]))
# print(type(pkt[Dot11WEP].iv))
iVal = pkt[Dot11WEP].iv
# print(iVal)
# print(keyText)
seed = self.seedGen(iVal, keyText)
## Remove the FCS so that we maintain packet size
pload = self.pt.byteRip(pkt[Dot11WEP],
order='last',
qty=4,
chop=True,
output='str')
## Return the stream, iv and seed
# print('\n\n\n')
# print(type(pload))
# print('\n')
# print(pload)
# print('\n\n\n')
# print(type(seed))
# print(seed)
return rc4(Dot11WEP(pload).wepdata, seed), iVal, seed
def _handle_in(self, packet):
if packet['opcode'] == 2:
self._out_key = packet['key']
self._out_cipher = rc4.rc4(hmac.new(self._login, self._hash + self._out_key).digest())
elif packet['opcode'] == 0:
for opcode, data in packet['packets']:
self.log_packet('s', opcode, data)
def encoder(self, pkt, iVal, keyText):
## Calculate the WEP Integrity Check Value (ICV)
# wepICV = self.pt.endSwap(hex(crc32(str(pkt[LLC])) & 0xffffffff))
wepICV = self.pt.endSwap(
hex(
crc32(
binascii.unhexlify(
hexstr(pkt[LLC], onlyhex=1).replace(' ', '')))
& 0xffffffff))
## Concatenate ICV to the [LLC]
# stream = str(pkt[LLC]) + binascii.unhexlify(wepICV.replace('0x', ''))
stream = binascii.unhexlify(
hexstr(pkt[LLC], onlyhex=1).replace(' ', '')) + binascii.unhexlify(
wepICV.replace('0x', ''))
# iVal = pkt[Dot11WEP].iv.decode('latin1')
# seed = self.seedGen(iVal, keyText).decode('latin1')
# return rc4(pkt.wepdata.decode('latin1'), iVal + seed), iVal, seed
## Return the encrypted data
# return rc4(stream, self.seedGen(iVal, keyText))
newStream = []
newStream.append(" ".join(
map(lambda stream: "%02x" % ord(stream), stream)))
newStream = " ".join(newStream)
# return rc4(newStream.decode('latin1'), self.seedGen(iVal, keyText))
return rc4(stream.decode('latin1'), self.seedGen(iVal, keyText))
def processClass(baseDir, className, strings, decoderClass, decoderMethod):
fileName = baseDir[:-1] + '/' + className
className = className[:-len('.smali')]
with open(fileName, 'r') as smaliFile:
lines = smaliFile.readlines()
key = generateKey()
encoder = rc4.rc4(key)
stringNames = []
encStrings = []
index = 0
for lineNum in strings.keys():
stringNames.append(generateStringFieldName(index))
encStrings.append(encoder.encode(strings[lineNum]))
newLine = getStringReplaceLine(lines[lineNum], stringNames[index],
className)
lines[lineNum] = newLine
index += 1
appendFields(lines, stringNames)
generateStaticConstructor(lines, className, key, stringNames, encStrings,
decoderClass, decoderMethod)
with open(fileName, 'w') as smaliFile:
smaliFile.writelines(lines)
def main(args, env):
pe = pefile.PE(args.file)
assert (len(pe.DIRECTORY_ENTRY_RESOURCE.entries) == 1)
resource_dir = pe.DIRECTORY_ENTRY_RESOURCE.entries[0]
resources = {}
for res in resource_dir.directory.entries:
name = str(res.name)
assert (len(res.directory.entries) == 1)
size = res.directory.entries[0].data.struct.Size
offset = res.directory.entries[0].data.struct.OffsetToData
data = pe.get_data(offset, size)
resources[name] = data
try:
key = resources['KEY']
CT = resources[args.resource]
PT = rc4.rc4(CT, key) # RC4 Decrypt Resource
uncompressed = lib.lznt1.dCompressBuf(PT) # LZNT1 Decompress
payload_pe = pefile.PE(data=uncompressed)
assert (len(payload_pe.get_warnings()) == 0
) # Verify uncompressed data is a valid PE
payload_data = payload_pe.trim()
with file(args.resource, "wb") as f:
f.write(payload_data)
print("Successfully Dumped payload {}".format(args.resource))
exit()
except Exception as e:
print("Failed to dump payload {}".format(args.resource))
return 1
def processClass(baseDir, className, strings, decoderClass, decoderMethod):
fileName = baseDir[:-1] + '/' + className
className = className[:-len('.smali')]
with open(fileName, 'r') as smaliFile:
lines = smaliFile.readlines()
key = generateKey();
encoder = rc4.rc4(key)
stringNames = []
encStrings = []
index = 0;
for lineNum in strings.keys():
stringNames.append(generateStringFieldName(index))
encStrings.append(encoder.encode(strings[lineNum]))
newLine = getStringReplaceLine(lines[lineNum], stringNames[index], className)
lines[lineNum] = newLine
index += 1
appendFields(lines, stringNames)
generateStaticConstructor(lines, className, key, stringNames, encStrings, decoderClass, decoderMethod)
with open(fileName, 'w') as smaliFile:
smaliFile.writelines(lines)
def _handle_out(self, packet):
if packet['opcode'] == 2:
self._in_key = packet['key']
self._in_cipher = rc4.rc4(hmac.new(self._login, self._hash + self._in_key).digest())
self._in_decomp = mppc.MPPCDecoder()
elif packet['opcode'] == 3:
self._login = packet['login']
self._hash = packet['hash']
def rc4_permutation(bitarray):
permutation_len = len(bitarray)
permutation_list = rc4(bitarray.bytes,
state_len=len(bitarray)).get_permutation_list()
output_data = BitArray()
for i in range(permutation_len):
output_data.append(BitArray(bin=bitarray.bin[permutation_list[i]]))
return output_data
def _handle_in(self, packet):
if packet['opcode'] == 2:
self._out_key = packet['key']
self._out_cipher = rc4.rc4(
hmac.new(self._login, self._hash + self._out_key).digest())
elif packet['opcode'] == 0:
for opcode, data in packet['packets']:
self.log_packet('s', opcode, data)
def run(keyFile, outputFile, inputFile):
with open(keyFile, "rb") as keyStream:
key = keyStream.read()
with open(inputFile, "rb") as inputStream:
data = inputStream.read()
output = rc4(key, data)
with open(outputFile, "wb") as outputStream:
outputStream.write(output)
def _handle_out(self, packet):
if packet['opcode'] == 2:
self._in_key = packet['key']
self._in_cipher = rc4.rc4(
hmac.new(self._login, self._hash + self._in_key).digest())
self._in_decomp = mppc.MPPCDecoder()
elif packet['opcode'] == 3:
self._login = packet['login']
self._hash = packet['hash']
def encrypt_pe_data(data, key):
encrypted = data
if args['data_compress']:
#encrypted = aplib.aplib_compress(encrypted).do()
encrypted = aplib2.pack(encrypted)
encrypted = rc4.rc4(encrypted, key)
if args['data_base64']:
encrypted = base64.b64encode(encrypted)
return encrypted
def encoder(self, pkt, iVal, keyText):
## Calculate the WEP Integrity Check Value (ICV)
wepICV = self.pt.endSwap(hex(crc32(str(pkt[LLC])) & 0xffffffff))
## Concatenate ICV to the [LLC]
stream = str(pkt[LLC]) + binascii.unhexlify(wepICV.replace('0x', ''))
## Return the encrypted data
return rc4(stream, self.seedGen(iVal, keyText))
def encode(text, key):
keystream = rc4.prga(rc4.ksa(key))
J = random.randint(0, 255)
k = [keystream.__next__() for i in range(255)]
k = "".join([chr(ki) for ki in k])
crc4 = rc4.rc4(text, keystream)
C1 = viginere.encrypt(crc4[:J], k[:J])
C2 = viginere.encrypt(crc4[J:], k[J:])
return C1 + C2 + str(J).zfill(3)
def get_file_contents(self, filename, keysize=0):
with open(filename, 'rb') as f:
data = f.read()
if keysize:
key = self.generate_key(keysize)
rc4.rc4_setkey(key)
data = key + rc4.rc4(data)
return data
def get_file_contents(self, filename, keysize=0):
with open(filename, 'rb') as f:
data = f.read()
if keysize:
key = self.generate_key(keysize)
rc4.rc4_setkey(key)
data = key + rc4.rc4(data)
return data
def system_info(data, key):
blob = b64decode(data, '_-')
cryptobj = rc4(key=key)
decrypted = cryptobj.crypt(blob)
(hostname, username, ip, proxy, id_, unknown) = decrypted.split('|')
chop.tsprnt("Beacon:")
chop.tsprnt("\tHostname: %s" % hostname)
chop.tsprnt("\tUsername: %s" % username)
chop.tsprnt("\tIP: %s" % ip)
chop.tsprnt("\tID: %s" % id_)
chop.tsprnt("\tUnknown: %s" % binascii.hexlify(unknown))
def decode(text, key):
J = int(text[-3:])
text = text[:-3]
keystream = rc4.prga(rc4.ksa(key))
k = [keystream.__next__() for i in range(255)]
k = "".join([chr(ki) for ki in k])
C1 = viginere.decrypt(text[:J], k[:J])
C2 = viginere.decrypt(text[J:], k[J:])
crc4 = rc4.rc4(C1 + C2, keystream)
return crc4
def cifrar(senha, octetos):
''' Cifrar octetos usando algoritmo RC4 como no Ciphersaber 2
O Ciphersaber 2 usa um vetor inicial de 10 octetos aleatórios concatenado
à senha do usuário, e 20 iterações no laço de inicialização do RC4.
fonte: http://ciphersaber.gurus.com/faq.html#cs2
'''
vetor_inicial = urandom(10)
senha = bytes(senha, CODIF) + vetor_inicial
return vetor_inicial + rc4(senha, octetos, 20)
def system_info(data, key):
blob = b64decode(data, '_-')
cryptobj = rc4(key=key)
decrypted = cryptobj.crypt(blob)
(hostname, username, ip, proxy, id_, unknown) = decrypted.split('|')
chop.tsprnt("Beacon:")
chop.tsprnt("\tHostname: %s" % hostname)
chop.tsprnt("\tUsername: %s" % username)
chop.tsprnt("\tIP: %s" % ip)
chop.tsprnt("\tID: %s" % id_)
chop.tsprnt("\tUnknown: %s" % binascii.hexlify(unknown))
def parseC0p(self):
self.RAW = self.getContent()
originLen = self.getDataLen()
self.parseTbl()
if b"" != self.key:
encedData = self.RAW[0x40:0x40 + originLen]
self.plainData = rc4.rc4(
encedData.decode("latin-1"),
self.key.decode("latin-1")).encode("latin-1")
else:
self.plainData = self.RAW[0x40:0x40 + originLen]
self.parseData()
def decypher(pkt):
# Build seed and decypher
key_stream = generate_seed(pkt[Dot11WEP].iv, args.pwd)
decyphered = rc4(pkt[Dot11WEP].wepdata, key_stream)
stack = LLC(decyphered)
if not (IP in stack and UDP in stack and Raw in stack):
return None
del pkt[Dot11FCS].fcs
del stack[IP].chksum
del stack[UDP].chksum
stack[IP].src, stack[IP].dst = stack[IP].dst, stack[IP].src
pkt[Dot11FCS].addr1, pkt[Dot11FCS].addr3 = pkt[Dot11FCS].addr3, pkt[
Dot11FCS].addr1
pkt[Dot11WEP].wepdata = rc4(bytes(stack), key_stream)
pkt[Dot11WEP].icv = crc32(bytes(stack))
return pkt
def __init__(self,
block_cipher_type="PCBC",
rc4_input_key='LucienD&IreneeD)',
initialization_numbe_bytes=b"ABCDEFGH"):
self.block_cipher_type = block_cipher_type
self.rc4_prng = rc4.rc4(rc4_input_key.encode())
self.initialization_number = int.from_bytes(initialization_numbe_bytes,
"little")
self.s_box_1 = self.rc4_prng.get_bytes(256)
self.s_box_2 = self.rc4_prng.get_bytes(256)
self.galois_field = pyfinite.ffield.FField(GALOIS_FIELD_SIZE)
def generate_niraidata(self):
print 'Generating niraidata'
config = self.get_file_contents('../dependencies/config/release/en.prc')
config += '\n\n' + self.get_file_contents('../dependencies/config/general.prc')
key = self.generate_key(128)
rc4.rc4_setkey(key)
config = key + rc4.rc4(config)
niraidata = 'CONFIG = %r' % config
niraidata += '\nDC = %r' % self.get_file_contents('../dependencies/astron/dclass/crystal.dc', 128)
self.add_module('niraidata', niraidata, compile=True)
def generate_niraidata(self):
print 'Generating niraidata'
config = self.get_file_contents('../src/dependencies/config/release/en.prc')
config += '\n\n' + self.get_file_contents('../src/dependencies/config/general.prc')
key = self.generate_key(128)
rc4.rc4_setkey(key)
config = key + rc4.rc4(config)
niraidata = 'CONFIG = %r' % config
niraidata += '\nDC = %r' % self.get_file_contents('../src/dependencies/astron/dclass/crystal.dc', 128)
self.add_module('niraidata', niraidata, compile=True)
def execution(path, body, module_data):
key = module_data['key']
opcodes = module_data['opcodes']
verbose = module_data['verbose']
blob = b64decode(path, '_-')
cryptobj = rc4(key=key)
decrypted = cryptobj.crypt(blob)
chop.tsprnt("Command request from %s" % decrypted)
if body:
data = b64decode(body, '_-')
cryptobj = rc4(key=key)
decrypted = cryptobj.crypt(data)
if len(decrypted) < 4:
chop.tsprnt("Command response length invalid.")
return
opcode = struct.unpack('<I', decrypted[:4])[0]
if opcode in opcodes:
opcodes[opcode](decrypted[4:])
else:
chop.tsprnt("Unknown opcode (%i)" % opcode)
if verbose:
chop.tsprnt("Data:\n%s" % hexdump(decrypted))
def execution(path, body, module_data):
key = module_data['key']
opcodes = module_data['opcodes']
verbose = module_data['verbose']
blob = b64decode(path, '_-')
cryptobj = rc4(key=key)
decrypted = cryptobj.crypt(blob)
chop.tsprnt("Command request from %s" % decrypted)
if body:
data = b64decode(body, '_-')
cryptobj = rc4(key=key)
decrypted = cryptobj.crypt(data)
if len(decrypted) < 4:
chop.tsprnt("Command response length invalid.")
return
opcode = struct.unpack('<I', decrypted[:4])[0]
if opcode in opcodes:
opcodes[opcode](decrypted[4:])
else:
chop.tsprnt("Unknown opcode (%i)" % opcode)
if verbose:
chop.tsprnt("Data:\n%s" % hexdump(decrypted))
def decoder(self, pkt, keyText):
"""Take a packet with [Dot11WEP] and apply RC4 to get the [LLC]"""
## Re-use the IV for comparative purposes
iVal = pkt[Dot11WEP].iv
seed = self.seedGen(iVal, keyText)
## Remove the FCS so that we maintain packet size
pload = self.pt.byteRip(pkt[Dot11WEP],
order='last',
qty=4,
chop=True,
output='str')
## Return the stream, iv and seed
return rc4(Dot11WEP(pload).wepdata, seed), iVal, seed
def perform_action(args):
"""
Parses the command line args and executes the encryption or decryption process
@param args The argparse object of command line args
"""
r = rc4() # initialize the rc4 class object (r)
r.key = args.key # set the key for the object to be the value from the command line
# if args.action is neither 'encrypt' nor 'decrypt', throw an error
if args.action == "encrypt":
if args.verbose:
print "Encrypting files..."
files = get_file_list(args.directory, args.recurse)
for f in files:
# don't run on already encrypted files, it will decrypt them
if f[-4:] != ".enc":
# add ".enc" to the end of each encrypted file
if args.verbose:
print "Encrypting " + f
enc_file = f + ".enc"
# encrypt the files
r.rc4main(f,enc_file)
# if requested, delete the original files
if args.cleanup:
if args.verbose:
print "Deleting " + f
os.remove(f)
elif args.action == "decrypt":
if args.verbose:
print "Decrypting files..."
files = get_file_list(args.directory, args.recurse)
for f in files:
if f[-4:] == ".enc":
if args.verbose:
print "Decrypting " + f
# method call to decrypt the files
r.rc4main(f,f[:-4])
if args.cleanup:
if args.verbose:
print "Deleting " + f
os.remove(f)
# else, if neither argument is specified, throw an error
else:
print "ERROR: -a must specify either 'encrypt' or 'decrypt' as an argument"
sys.exit(1)
def encoder(self, pkt, iVal, keyText):
## Calculate the WEP Integrity Check Value (ICV)
#wepICV = crc32(str(pkt[LLC]))
wepICV = crc32(str(pkt[LLC])) & 0xffffffff
plainText = str(pkt[LLC])
#print 'wepICV is: ', wepICV
#print 'hex of ^ is: ', hex(wepICV)
#print 'unhexlify of ^ is: ', unhexlify(re.sub('0x', '', hex(wepICV)))
#print 'repr of ^ is: ', repr(unhexlify(re.sub('0x', '', hex(wepICV))))
#stream = plainText + str(wepICV)
#stream = plainText + hex(wepICV)
#stream = plainText + unhexlify(re.sub('0x', '', hex(wepICV)))
stream = plainText
## crypt
seed = self.seedGen(iVal, unhexlify(keyText))
return rc4(stream, seed), wepICV
def WANNA_decrypt(orifile, privkey, out):
if os.path.exists(orifile) is False:
return
newfile = os.path.join(out, os.path.basename(orifile))
if newfile.endswith('.WannaRen'):
newfile = newfile[:-9]
#for big file hang
with open(orifile, 'rb') as enc_file:
enc = enc_file.read(11)
if enc != 'WannaRenkey':
return
with open(orifile, 'rb') as enc_file:
enc = enc_file.read()
p1 = enc.find('WannaRenkey')
p2 = enc.find('WannaRen1')
p3 = enc.find('WannaRen2')
benc = p1 == 0 and p2 > 0 and p3 > 0
if benc == False:
#print "file:%s is not encrypt"%orifile
return
print "decrypting %s" % (orifile)
#rc4 key
rc4_key = rsa.decrypt(enc[11:267], privkey).decode()
#rc4 decrypt
#WannaRen1{data}WannaRen2
data = enc[p2 + 9:-9]
res = rc4.rc4(data, rc4_key)
#save to new file
#WannaRena{filedata}WannaRenb
if res.find("WannaRena") < 0 or res.find("WannaRenb") < 0:
print "decrypt %s failed." % (orifile)
with open(newfile, 'wb') as n:
n.write(res[9:-9])
print "decrypt %s to %s" % (orifile, newfile)
def process_modules(self):
with open('base.dg', 'rb') as f:
basesize, = struct.unpack('<I', f.read(4))
data = f.read()
dg = Datagram()
dg.addUint32(len(self.modules) + basesize)
dg.appendData(data)
for moduleName in self.modules:
data, size = self.modules[moduleName]
dg.addString(moduleName)
dg.addInt32(size)
dg.appendData(data)
data = dg.getMessage()
compressed = compressString(data, 9)
key = self.generate_key(100)
fixed = ''.join(chr((i ^ (5 * i + 7)) % ((i + 6) * 10)) for i in xrange(28))
rc4.rc4_setkey(key + fixed)
data = rc4.rc4(compressed)
return key + data
def process_modules(self):
with open('base.dg', 'rb') as f:
basesize, = struct.unpack('<I', f.read(4))
data = f.read()
dg = Datagram()
dg.addUint32(len(self.modules) + basesize)
dg.appendData(data)
for moduleName in self.modules:
data, size = self.modules[moduleName]
dg.addString(moduleName)
dg.addInt32(size)
dg.appendData(data)
data = dg.getMessage()
compressed = compressString(data, 9)
key = self.generate_key(100)
fixed = ''.join(chr((i ^ (5 * i + 7)) % ((i + 6) * 10)) for i in xrange(28))
rc4.rc4_setkey(key + fixed)
data = rc4.rc4(compressed)
return key + data
def decoder(self, pkt, keyText):
"""Take a packet with [Dot11WEP] and apply RC4 to get the [LLC]
This function should not need to return fullStream,
however, because of quirks I've noticed, I return
fullStream and stream.
The seed doesn't need to be returned, but why calculate again...
"""
## Re-use the IV for comparative purposes
iVal = pkt[Dot11WEP].iv
seed = self.seedGen(iVal, unhexlify(keyText))
## Grab full stream
fullStream = rc4(pkt[Dot11WEP].wepdata, seed)
## Prep for removing the 4 icv bytes
tmp = []
stream = ''
for i in range(len(fullStream) - 4):
tmp.append(fullStream[i])
for i in tmp:
stream += i
## Return the fullstream, stream and iv
return fullStream, stream, iVal, seed
0xEE,
0xF7,
0x01,
0x79,
0xBC,
0x55,
0x3F,
0x33,
0x9E,
0xB1,
0xA4,
0xC1,
0xAF,
0x5F,
0x6A,
0x54,
0x7F,
),
},
),
]
for name, vectors in TEST_VECTORS:
print(name, end="")
entrada = bytearray(vectors["Plain Text"])
saida = bytearray(vectors["Cipher Text"])
chave = bytearray(vectors["Key"])
assert saida == rc4(chave, entrada)
assert entrada == rc4(chave, saida)
print(" --> OK")
0xb2, 0x13, 0xf0, 0xed, 0x1a, 0xa7, 0x2f, 0xb8, 0xea, 0x52, 0xb0,
0xbe, 0x01, 0xcd, 0x1e, 0x41, 0x28, 0x67, 0x72, 0x0b, 0x32, 0x6e,
0xb3, 0x89, 0xd0, 0x11, 0xbd, 0x70, 0xd8, 0xaf, 0x03, 0x5f, 0xb0,
0xd8, 0x58, 0x9d, 0xbc, 0xe3, 0xc6, 0x66, 0xf5, 0xea, 0x8d, 0x4c,
0x79, 0x54, 0xc5, 0x0c, 0x3f, 0x34, 0x0b, 0x04, 0x67, 0xf8, 0x1b,
0x42, 0x59, 0x61, 0xc1, 0x18, 0x43, 0x07, 0x4d, 0xf6, 0x20, 0xf2,
0x08, 0x40, 0x4b, 0x39, 0x4c, 0xf9, 0xd3, 0x7f, 0xf5, 0x4b, 0x5f,
0x1a, 0xd8, 0xf6, 0xea, 0x7d, 0xa3, 0xc5, 0x61, 0xdf, 0xa7, 0x28,
0x1f, 0x96, 0x44, 0x63, 0xd2, 0xcc, 0x35, 0xa4, 0xd1, 0xb0, 0x34,
0x90, 0xde, 0xc5, 0x1b, 0x07, 0x11, 0xfb, 0xd6, 0xf5, 0x5f, 0x79,
0x23, 0x4d, 0x5b, 0x7c, 0x76, 0x66, 0x22, 0xa6, 0x6d, 0xe9, 0x2b,
0xe9, 0x96, 0x46, 0x1d, 0x5e, 0x4d, 0xc8, 0x78, 0xef, 0x9b, 0xca,
0x03, 0x05, 0x21, 0xe8, 0x35, 0x1e, 0x4b, 0xae, 0xd2, 0xfd, 0x04,
0xf9, 0x46, 0x73, 0x68, 0xc4, 0xad, 0x6a, 0xc1, 0x86, 0xd0, 0x82,
0x45, 0xb2, 0x63, 0xa2, 0x66, 0x6d, 0x1f, 0x6c, 0x54, 0x20, 0xf1,
0x59, 0x9d, 0xfd, 0x9f, 0x43, 0x89, 0x21, 0xc2, 0xf5, 0xa4, 0x63,
0x93, 0x8c, 0xe0, 0x98, 0x22, 0x65, 0xee, 0xf7, 0x01, 0x79, 0xbc,
0x55, 0x3f, 0x33, 0x9e, 0xb1, 0xa4, 0xc1, 0xaf, 0x5f, 0x6a, 0x54,
0x7f),
}),
]
for name, vectors in TEST_VECTORS:
print name,
entrada = ''.join([chr(n) for n in vectors['Plain Text']])
saida = ''.join([chr(n) for n in vectors['Cipher Text']])
chave = ''.join([chr(n) for n in vectors['Key']])
assert saida == rc4(chave, entrada)
assert entrada == rc4(chave, saida)
print 'OK'
from panda3d.core import *
import __builtin__, os
import rc4
import niraidata
# Config
prc = niraidata.CONFIG
key, prc = prc[:32], prc[32:]
rc4.rc4_setkey(key)
prc = rc4.rc4(prc)
for line in prc.split('\n'):
line = line.strip()
if line:
loadPrcFileData('nirai config', line)
del prc
# DC
__builtin__.dcStream = StringStream()
dc = niraidata.DC
key, dc = dc[:32], dc[32:]
rc4.rc4_setkey(key)
dc = rc4.rc4(dc)
dcStream.setData(dc)
del dc
rc4.rc4_setkey('\0\0\0\0')
def oracle(req):
key = os.urandom(16)
cookie = 'QkUgU1VSRSBUTyBEUklOSyBZT1VSIE9WQUxUSU5F'.decode('base64')
return rc4(key).encrypt(req + cookie)
def cifrar(chave, entrada, loops=20):
vetor_inicial = urandom(10)
chave = chave + vetor_inicial
return vetor_inicial + rc4(chave, entrada, loops)
def decifrar(chave, entrada, loops=20):
chave = chave + entrada[:10]
entrada = entrada[10:]
return rc4(chave, entrada, loops)
def decifrar(senha, octetos):
''' Decifrar octetos usando algoritmo RC4 como no Ciphersaber 2 '''
senha = bytes(senha, CODIF) + octetos[:10]
octetos = octetos[10:]
return rc4(senha, octetos, 20)
def decifrar(senha, bytes):
''' Decifrar bytes usando algoritmo RC4 como no Ciphersaber 2 '''
senha = senha + bytes[:10]
bytes = bytes[10:]
return rc4(senha, bytes, 20)
def encrypt(msg):
return rc4.rc4(map(ord, whatever_key)).encrypt(map(ord, msg))
