Present python implementation - Revision history

Tiftof: deleted comments from during development

2008-10-16T00:00:10Z

deleted comments from during development

← Older revision		Revision as of 00:00, 16 October 2008
Line 3:		Line 3:
	The code is available [http://repo.or.cz/w/python-cryptoplus.git?a=blob;f=src/CryptoPlus/Cipher/pypresent.py;hb=HEAD here]		The code is available [http://repo.or.cz/w/python-cryptoplus.git?a=blob;f=src/CryptoPlus/Cipher/pypresent.py;hb=HEAD here]

			Features:
	what should be working (only tested with 1 or 2 test vectors yet):
	* calculating round keys		* calculating round keys
	** to have the same results as the reference C implementation, salting the roundkeys should only XOR 5 bits with roundkey when using 128bits key (line 95 in code) but should XOR with no 5bits limit when using 80bits key (line 76 in code). But the standard describes that it should be limited to 5 bits for both key generators...
	* encrypting a block		* encrypting a block
	* decrypting a block		* decrypting a block
			* supports amount of rounds different from the standard amount of 32
	* ~~should support rounds up to 65534 (~~tested with 32, 64, 128 and 65534 rounds)		** tested with 32, 64, 128 and 65534 rounds
	** decryption testvectors have errors: the sbox on decryption behaves like the inverse of the p-box... every S-Box value is incorrect in the testvectors.<br>Example:
			** PRESENT reference implementation supports amount of rounds up to 65534
	Round 1
	Subkey: 6dab31744f41d700
	Text after...
	...Key-Xor: 38d2f04c34635345
	.....P-Box: 45ef82118f2845a3
	.....S-Box: 38d2f04c34635345

PhilippeTeuwen at 21:31, 15 October 2008

2008-10-15T21:31:14Z

Show changes

Tiftof at 11:39, 6 October 2008

2008-10-06T11:39:28Z

← Older revision		Revision as of 11:39, 6 October 2008
Line 1:		Line 1:
	what should be working (only tested with 1 or 2 test vectors yet):		what should be working (only tested with 1 or 2 test vectors yet):
	* calculating round keys		* calculating round keys
			** to have the same results as the reference C implementation, salting the roundkeys should only XOR 5 bits with roundkey when using 128bits key (line 95 in code) but should XOR with no 5bits limit when using 80bits key (line 76 in code). But the standard describes that it should be limited to 5 bits for both key generators...
	* encrypting a block		* encrypting a block
	* decrypting a block		* decrypting a block
	* should support rounds up to 65534 (tested with 32 and 64 rounds ~~only~~)		* should support rounds up to 65534 (tested with 32, 64, 128 and 65534 rounds)
	** decryption testvectors have errors: the sbox on decryption behaves like the inverse of the p-box... every S-Box value is incorrect in the testvectors.<br>Example:		** decryption testvectors have errors: the sbox on decryption behaves like the inverse of the p-box... every S-Box value is incorrect in the testvectors.<br>Example:
	Round 1		Round 1
Line 20:		Line 21:
	def __init__(self,key,rounds=32):		def __init__(self,key,rounds=32):
	"""Generating roundkeys		"""Generating roundkeys


	When a Present class initialized, the roundkeys will be generated.		When a Present class initialized, the roundkeys will be generated.
	You can supply the key as a 128bit or 80bit rawstring.		You can supply the key as a 128bit or 80bit rawstring.
Line 35:		Line 36:
	def encrypt(self,block):		def encrypt(self,block):
	"""Encrypting 1 block (8 bytes)		"""Encrypting 1 block (8 bytes)


	Supply the plaintext block as a raw string and the raw		Supply the plaintext block as a raw string and the raw
	ciphertext will be returned.		ciphertext will be returned.
Line 49:		Line 50:
	def decrypt(self,block):		def decrypt(self,block):
	"""Decrypting 1 block (8 bytes)		"""Decrypting 1 block (8 bytes)


	Supply the ciphertext block as a raw string and the raw		Supply the ciphertext block as a raw string and the raw
	plaintext will be returned.		plaintext will be returned.
Line 62:		Line 63:

	def get_block_size(self):		def get_block_size(self):
	return 16		return 8

	# 0 1 2 3 4 5 6 7 8 9 a b c d e f		# 0 1 2 3 4 5 6 7 8 9 a b c d e f
Line 73:		Line 74:
	def generateRoundkeys80(key,rounds):		def generateRoundkeys80(key,rounds):
	"""Generate the roundkeys for a 80 bit key		"""Generate the roundkeys for a 80 bit key


	Give a 80bit hex string as input and get a list of roundkeys in return"""		Give a 80bit hex string as input and get a list of roundkeys in return"""
	roundkeys = []		roundkeys = []
	for i in range(1,rounds+1): # (K0 ... K32)		for i in range(1,rounds+1): # (K0 ... K32)
	print i
	# rawKey[0:63]		# rawKey[0:63]
	roundkeys.append(("%x" % (int(key,16) >>16 )).zfill(64/4))		roundkeys.append(("%x" % (int(key,16) >>16 )).zfill(64/4))
Line 86:		Line 86:
	#rawKey[76:79] = S(rawKey[76:79])		#rawKey[76:79] = S(rawKey[76:79])
	key = SBox[int(key[0],16)]+key[1:20]		key = SBox[int(key[0],16)]+key[1:20]
	#print "sbox"
	#print key
	#3. Salt		#3. Salt
	#rawKey[15:19] ^ i		#rawKey[15:19] ^ i
	temp = (int(key,16) >> 15)		temp = (int(key,16) >> 15)
	temp = (temp ^ i )		temp = temp ^ i
	key = ( int(key,16) & (pow(2,15)-1) ) + (temp << 15)		key = ( int(key,16) & (pow(2,15)-1) ) + (temp << 15)
	key = ("%x" % key).zfill(80/4)		key = ("%x" % key).zfill(80/4)
Line 98:		Line 96:
	def generateRoundkeys128(key,rounds):		def generateRoundkeys128(key,rounds):
	"""Generate the roundkeys for a 128 bit key		"""Generate the roundkeys for a 128 bit key


	Give a ~~80bit~~ hex string as input and get a list of roundkeys in return"""		Give a 128bit hex string as input and get a list of roundkeys in return"""
	roundkeys = []		roundkeys = []
	for i in range(1,rounds+1): # (K0 ... K32)		for i in range(1,rounds+1): # (K0 ... K32)
Line 109:		Line 107:
	#3. Salt		#3. Salt
	#rawKey[15:19] ^ i		#rawKey[15:19] ^ i
	temp = (int(key,16) >> 62) ~~& (pow(2,5)-1) # rawKey[15:19]~~		temp = (int(key,16) >> 62)
	temp = temp ^ i		temp = temp ^ (i%32)
	key = ( int(key,16) & (pow(2,62)-1) ) + (temp << 62~~) + ( (int(key,16) >> 67) <<67~~ )		key = ( int(key,16) & (pow(2,62)-1) ) + (temp << 62)
	key = "%x" % key		key = ("%x" % key).zfill(128/4)
	return roundkeys		return roundkeys

Line 120:		Line 118:
	def sBoxLayer(state):		def sBoxLayer(state):
	"""SBox function for encryption		"""SBox function for encryption


	Takes a hex string as input and will output a hex string"""		Takes a hex string as input and will output a hex string"""
	output =''		output =''
Line 129:		Line 127:
	def sBoxLayer_dec(state):		def sBoxLayer_dec(state):
	"""Inverse SBox function for decryption		"""Inverse SBox function for decryption


	Takes a hex string as input and will output a hex string"""		Takes a hex string as input and will output a hex string"""
	output =''		output =''
Line 138:		Line 136:
	def pLayer(state):		def pLayer(state):
	"""Permutation layer for encryption		"""Permutation layer for encryption


	Takes a 64bit hex string as input and will output a 64bit hex string"""		Takes a 64bit hex string as input and will output a 64bit hex string"""
	output = ''		output = ''
Line 148:		Line 146:
	def pLayer_dec(state):		def pLayer_dec(state):
	"""Permutation layer for decryption		"""Permutation layer for decryption


	Takes a 64bit hex string as input and will output a 64bit hex string"""		Takes a 64bit hex string as input and will output a 64bit hex string"""
	output = ''		output = ''

Tiftof: code update

2008-10-05T11:45:39Z

code update

Show changes

Tiftof at 10:16, 4 October 2008

2008-10-04T10:16:30Z

← Older revision		Revision as of 10:16, 4 October 2008
Line 2:		Line 2:
	* calculating round keys		* calculating round keys
	* encrypting a block		* encrypting a block
			* decrypting a block
			** decryption testvectors have errors: the sbox on decryption behaves like the inverse of the p-box... every S-Box value is incorrect in the testvectors.<br>Example:
			Round 1
			Subkey: 6dab31744f41d700
			Text after...
			...Key-Xor: 38d2f04c34635345
			.....P-Box: 45ef82118f2845a3
			.....S-Box: 38d2f04c34635345
	{{#fileanchor: pypresent.py}}		{{#fileanchor: pypresent.py}}
	<source lang=python>		<source lang=python>

Tiftof at 10:12, 4 October 2008

2008-10-04T10:12:01Z

Show changes

Tiftof at 08:50, 4 October 2008

2008-10-04T08:50:18Z

← Older revision		Revision as of 08:50, 4 October 2008
Line 2:		Line 2:
	* calculating round keys		* calculating round keys
	* encrypting a block		* encrypting a block
	{{#fileanchor: ~~pyserpent~~.py}}		{{#fileanchor: pypresent.py}}
	<source lang=python>		<source lang=python>
	class Present:		class Present:
Line 127:		Line 127:
	return s		return s
	</source>		</source>
	Download code: [{{#filelink: ~~pyserpent~~.py}} ~~pyserpent~~.py]		Download code: [{{#filelink: pypresent.py}} pypresent.py]

PhilippeTeuwen: Present python implementatin moved to Present python implementation: typo

2008-10-02T19:45:55Z

Present python implementatin moved to Present python implementation: typo

← Older revision	Revision as of 19:45, 2 October 2008
(No difference)

Tiftof: New page: what should be working (only tested with 1 or 2 test vectors yet): * calculating round keys * encrypting a block {{#fileanchor: pyserpent.py}} class Present: def __i...

2008-10-02T18:51:41Z

New page: what should be working (only tested with 1 or 2 test vectors yet): * calculating round keys * encrypting a block {{#fileanchor: pyserpent.py}} <source lang=python> class Present: def __i...

New page

what should be working (only tested with 1 or 2 test vectors yet):
* calculating round keys
* encrypting a block
{{#fileanchor: pyserpent.py}}
<source lang=python>
class Present:

def __init__(self,key):
self.key = key.encode('hex')
if len(self.key) == 80/4:
self.roundkeys = generateRoundkeys80(self.key)
elif len(self.key) == 128/4:
self.roundkeys = generateRoundkeys128(self.key)
else:
pass

def encrypt(self,block):
state = block.encode('hex')

for i in range (1,32):
state = addRoundKey(state,self.roundkeys[i-1])
#print "roundkey"
#print state
state = sBoxLayer(state)
#print "sbox"
#print state
state = pLayer(state)
#print "pLayer"
#print state
cipher = addRoundKey(state,self.roundkeys[31])

return cipher

def decrypt(self,block):
pass

def get_block_size(self):
return 16

SBox = ('c','5','6','b','9','0','a','d','3','e','f','8','4','7','1','2')
PBox = [0,16,32,48,1,17,33,49,2,18,34,50,3,19,35,51,
4,20,36,52,5,21,37,53,6,22,38,54,7,23,39,55,
8,24,40,56,9,25,41,57,10,26,42,58,11,27,43,59,
12,28,44,60,13,29,45,61,14,30,46,62,15,31,47,63]

def generateRoundkeys80(key):
# input: hex string ex. 'ffff'
roundkeys = []
for i in range(1,33): # (K0 ... K32)
# rawKey[0:63]
roundkeys.append(("%x" % (int(key,16) >>16 )).zfill(64/4))
#1. Shift
#rawKey[19:(len(rawKey)-1)]+rawKey[0:18]
key = ("%x" % ( ((int(key,16) & (pow(2,19)-1)) << 61) + (int(key,16) >> 19))).zfill(80/4)
#print "shift"
#print key
#2. SBox
#rawKey[76:79] = S(rawKey[76:79])
key = S(key[0])+key[1:20]
#print "sbox"
#print key
#3. Salt
#rawKey[15:19] ^ i
temp = (int(key,16) >> 15) & (pow(2,5)-1) # rawKey[15:19]
temp = temp ^ i
key = ( int(key,16) & (pow(2,15)-1) ) + (temp << 15) + ( (int(key,16) >> 20) <<20 )
key = "%x" % key
#print "salt"
#print key
return roundkeys

def generateRoundkeys128(key):
# input: hex string ex. 'ffff'
roundkeys = []
for i in range(1,33): # (K0 ... K32)
roundkeys.append(("%x" % (int(key,16) >>64)).zfill(64/4))
#1. Shift
key = ("%x" % ( ((int(key,16) & (pow(2,67)-1)) << 61) + (int(key,16) >> 67))).zfill(128/4)
print "shift"
print key
#2. SBox
key = S(key[0])+S(key[1])+key[2:]
print "sbox"
print key
#3. Salt
#rawKey[15:19] ^ i
temp = (int(key,16) >> 62) & (pow(2,5)-1) # rawKey[15:19]
temp = temp ^ i
key = ( int(key,16) & (pow(2,62)-1) ) + (temp << 62) + ( (int(key,16) >> 67) <<67 )
key = "%x" % key
print "salt"
print key
return roundkeys

def S(toS):
#apply 4bit Sbox to a hexstring
final =''
for i in range (0,len(toS)):
final += SBox[int(toS[i],16)]
#return convertToBitstring(final,len(toS)*8)[::-1]
return final

def addRoundKey(state,roundkey):
return ( "%x" % ( int(state,16) ^ int(roundkey,16) ) ).zfill(16)

def sBoxLayer(state):
output =''
for i in range(len(state)):
output += S(state[i])
return output

def pLayer(state):
output = ''
state_bin = bin(int(state,16)).zfill(64)[::-1][0:64]
for i in range(64):
output += state_bin[PBox.index(i)]
return "%x" % int(output[::-1],2)

def bin(a):
#int to bin
#http://wiki.python.org/moin/BitManipulation
s=''
t={'0':'000','1':'001','2':'010','3':'011','4':'100','5':'101','6':'110','7':'111'}
for c in oct(a).rstrip('L')[1:]:
s+=t[c]
return s
</source>
Download code: [{{#filelink: pyserpent.py}} pyserpent.py]