Sage Sandbox - Revision history

PhilippeTeuwen: /* Helper functions */

2011-07-18T11:18:48Z

Helper functions

← Older revision		Revision as of 11:18, 18 July 2011
Line 49:		Line 49:
	#3.78 µs per loop		#3.78 µs per loop
	###################################################################################		###################################################################################
	('%0*x' % (32 , 123456789012345678901234)).decode('hex')		('%0x' % (2 16 , 123456789012345678901234)).decode('hex')
	#2.06 µs per loop		#2.06 µs per loop
	('%0*x' % (32 , 1234567890123456789012345)).decode('hex')		('%0x' % (2 16 , 1234567890123456789012345)).decode('hex')
	#2.01 µs per loop		#2.01 µs per loop
	#Ok if you want fixed length buffer, e.g. 32 bytes		#Ok if you want fixed length buffer, e.g. 16 bytes
	###################################################################################		###################################################################################
	def long2string(i):		def long2string(i):
Line 116:		Line 116:
	###################################################################################		###################################################################################
	int('\x01\x05n\x0f6\xa6D=\xe2\xdfy'.encode('hex'),16)		int('\x01\x05n\x0f6\xa6D=\xe2\xdfy'.encode('hex'),16)
	#3.15 µs per loop
	###################################################################################
	int('\x01\x05n\x0f6\xa6D=\xe2\xdfy'.decode('hex'),16)
	#1.64 µs per loop		#1.64 µs per loop
	###################################################################################		###################################################################################
	long('\x01\x05n\x0f6\xa6D=\xe2\xdfy'.~~decode~~('hex'),16)		long('\x01\x05n\x0f6\xa6D=\xe2\xdfy'.encode('hex'),16)
	#1.38 µs per loop		#1.38 µs per loop
	</source>		</source>

Newacct at 06:56, 24 December 2009

2009-12-24T06:56:55Z

Show changes

Tiftof: /* Learning Python */

2008-08-25T14:18:01Z

Learning Python

← Older revision		Revision as of 14:18, 25 August 2008
Line 246:		Line 246:
	pattern = padded[-1]		pattern = padded[-1]
	length = int(hexlify(pattern),16)		length = int(hexlify(pattern),16)
			#check if the bytes to be removed are all the same pattern
	flag = 0
	~~for~~ ~~i in range~~(1,length ~~+ 1~~):		if padded.endswith(pattern*length):
	if padded[-i] ~~<> pattern:~~		return padded[:-length]
	flag = 1
	if flag == 0:
	unpadded = padded[:-length]
	else:		else:
	~~unpadded =~~ padded		return padded
	print 'error: padding pattern not recognized'		print 'error: padding pattern not recognized'
	return unpadded

	def __ANSI_X923 (self, toPad ):		def __ANSI_X923 (self, toPad ):
Line 269:		Line 265:
	return padded[:-length]		return padded[:-length]
	else:		else:
	unpadded = padded
	print 'error: padding pattern not recognized %s' % padded.count('\x00',-length,-1)		print 'error: padding pattern not recognized %s' % padded.count('\x00',-length,-1)
	return unpadded		return unpadded

	def __ISO_10126 (self, toPad):		def __ISO_10126 (self, toPad):

Tiftof: /* Learning Python */

2008-08-25T13:11:13Z

Learning Python

← Older revision		Revision as of 13:11, 25 August 2008
Line 153:		Line 153:

	import sys		import sys
	import ~~getopt~~		from optparse import OptionParser

	try:		try:
Line 190:		Line 190:

	def pad (self, toPad, algo):		def pad (self, toPad, algo):
	~~return getattr(self,"_Padding__%s" % algo)(toPad)~~ #private function has to be accessed by it's public name...		#private function has to be accessed by it's public name when using getattr...
			return getattr(self,"_%(classname)s__%(algo)s" % {'classname':self.__class__.__name__,'algo':algo})(toPad)

	def unpad (self, padded, algo):		def unpad (self, padded, algo):
Line 213:		Line 214:
	def __bitPadding_unpad (self, padded ):		def __bitPadding_unpad (self, padded ):
	if padded.rstrip('\x00')[-1] == '\x80':		if padded.rstrip('\x00')[-1] == '\x80':
	return padded.rstrip(~~'\x80' +~~ '\x00')		return padded.rstrip('\x00')[:-1]
	else:		else:
	return padded		return padded
Line 236:		Line 237:

	pattern = self.blockSize - len(toPad)%self.blockSize		pattern = self.blockSize - len(toPad)%self.blockSize
	# 0 -> zero padding for numeric values; 2 -> print "String to be padded: %r" % toPadlength modifier; x -> hex output
	# string formatting options: http://docs.python.org/lib/typesseq-strings.html
	code = "%02x" % pattern		code = "%02x" % pattern
	patternstring = ('\\x' + code).decode('string_escape')		patternstring = ('\\x' + code).decode('string_escape')
Line 284:		Line 283:

	def main():		def main():
			usage = "usage: %prog [options] [texttopad]"
	try:
			parser = OptionParser(usage=usage)
	opts, args = getopt.getopt(sys.argv[1:], "")
			parser.add_option("-b", "--blocksize", dest='blocksize', default=8, help="specify the bloksize", type='int')
	except getopt.GetoptError, err:
			(options, args) = parser.parse_args()
	print str(err)

	sys.exit(2)
	if len(args) > 1:		if len(args) > 1:
	~~sys~~.~~exit~~("Program takes maximum 1 argument")		parser.error("Program takes maximum 1 argument")

	try:		try:
	testbench(args[0])		testbench(args[0].decode('string_escape'),options.blocksize)
	except IndexError:		except IndexError:
	testbench()		testbench(blocksize=options.blocksize)

	def testbench(toPad='test'):		def testbench(toPad='test',blocksize=8):
	testbench = ('bitPadding','zerosPadding','PKCS7','ANSI_X923','ISO_10126')		testbench = ('bitPadding','zerosPadding','PKCS7','ANSI_X923','ISO_10126')
	padder = Padding()		padder = Padding(blocksize)
	print "String to be padded: %r, with length %i\n" % (toPad,len(toPad))		print "String to be padded: %r, with length %i\n" % (toPad,len(toPad))
	for test in testbench:		for test in testbench:

Tiftof: /* Learning Python */

2008-08-25T08:58:26Z

Learning Python

Show changes

Tiftof: /* Learning Python */

2008-08-24T19:08:59Z

Learning Python

← Older revision		Revision as of 19:08, 24 August 2008
Line 182:		Line 182:
	padder.unpad(padded,'bitpadding)		padder.unpad(padded,'bitpadding)
	"""		"""

			#def __getattr__(self, name):
			# #this is called when getattr() called on this object doesn't find the attribute wanted
			# #this will now try to see if it can find a private function
			# return getattr(self,"_Padding__" + name)


	def pad (self, toPad, algo):		def pad (self, toPad, algo):
			return getattr(self,"_Padding__%s" % algo)(toPad) #private function has to be accessed by it's public name...


		⚫	def unpad (self, padded, algo):
	#there is no switch statement in python		#there is no switch statement in python
	#discussion with alternatives: http://simonwillison.net/2004/May/7/switch/		#discussion with alternatives: http://simonwillison.net/2004/May/7/switch/
	if algo == 'bitpadding':
	return self.__bitPadding(toPad)
	elif algo == 'zerospadding':
	return self.__zerosPadding(toPad)
	elif algo == 'PKCS7':
	return self.__PKCS7(toPad)
	elif algo == 'ANSI_X923':
	return self.__ANSI_X923(toPad)
	elif algo == 'ISO_10126':
	return self.__ISO_10126(toPad)
	raise NotImplementedError()

⚫	def unpad (self, padded, algo):
	if algo == 'bitpadding':		if algo == 'bitpadding':
	return self.__bitPadding_unpad(padded)		return self.__bitPadding_unpad(padded)
Line 315:		Line 312:
	print "Test OK!"		print "Test OK!"
	else:		else:
	print "Test not OK!"		print "Test not OK!"
	</source>		</source>
	Download code: [{{#filelink: padding.py}} padding.py]		Download code: [{{#filelink: padding.py}} padding.py]

Tiftof: /* Learning Python */

2008-08-24T18:19:07Z

Learning Python

← Older revision		Revision as of 18:19, 24 August 2008
Line 127:		Line 127:
	==Learning Python==		==Learning Python==
	Some code to make some padding functions available. The code is used as a way to learn python, so it contains things that don't make sense or could be done better.		Some code to make some padding functions available. The code is used as a way to learn python, so it contains things that don't make sense or could be done better.

			{{#fileanchor: helper.py}}
			<source lang=python>
			from __future__ import division #http://www.python.org/dev/peps/pep-0238/
			import math

			def roundUp (n, p):
			"""Round an integer up to the nearest multiple

			A given integer n will be round up to the nearest multiple of p

			Example:
			>>> roundUp(13,8)
			16
			"""
			return int(math.ceil(n/p)*p)
			#return (n+p)/p*p
			</source>
			Download code: [{{#filelink: helper.py}} helper.py]

	{{#fileanchor: padding.py}}		{{#fileanchor: padding.py}}
	<source lang=python>		<source lang=python>
			#Als input al multiple van blocksize is, dan toch padden?
			#bij ansi en iso zou ge de laatste byte verkeerd kunnen interpreteren als toch gepad ipv niet

	from binascii import hexlify		from binascii import hexlify
			import random

			try:
			import helper
			except ImportError:
			print 'ERROR: helper.py should be placed in the same location as padding.py'
			raise ImportError

	class BlockOperator:		class BlockOperator:
Line 164:		Line 194:
	elif algo == 'ANSI_X923':		elif algo == 'ANSI_X923':
	return self.__ANSI_X923(toPad)		return self.__ANSI_X923(toPad)
			elif algo == 'ISO_10126':
			return self.__ISO_10126(toPad)
	raise NotImplementedError()		raise NotImplementedError()

	def unpad (self, ~~toPad~~, algo):		def unpad (self, padded, algo):
	if algo == 'bitpadding':		if algo == 'bitpadding':
	return self.__bitPadding_unpad(~~toPad~~)		return self.__bitPadding_unpad(padded)
	elif algo == 'zerospadding':		elif algo == 'zerospadding':
	return self.__zerosPadding_unpad(~~toPad~~)		return self.__zerosPadding_unpad(padded)
	elif algo == 'PKCS7':		elif algo == 'PKCS7':
	return self.__PKCS7_unpad(~~toPad~~)		return self.__PKCS7_unpad(padded)
	elif algo == 'ANSI_X923':		elif algo == 'ANSI_X923':
	return self.__ANSI_X923_unpad(~~toPad~~)		return self.__ANSI_X923_unpad(padded)
			elif algo == 'ISO_10126':
			return self.__ISO_10126_unpad(padded)
	raise NotImplementedError()		raise NotImplementedError()

Line 188:		Line 222:

	def __zerosPadding (self, toPad ):		def __zerosPadding (self, toPad ):
	if 0 <> len(toPad)%self.blockSize:		#if 0 <> len(toPad)%self.blockSize:
	~~padded~~ = ~~toPad +~~ '\x00'*(self.blockSize - len(toPad)%self.blockSize)		# pad = '\x00'*(self.blockSize - len(toPad)%self.blockSize)
	else:		#else:
	~~padded~~ = ~~toPad~~		# pad = ''
	return ~~padded~~		#return ''.join([toPad,pad])
			totalLength = helper.roundUp(len(toPad),self.blockSize)
			return toPad.ljust(totalLength,'\x00')


	def __zerosPadding_unpad (self, padded ):		def __zerosPadding_unpad (self, padded ):
Line 212:		Line 249:
	# string formatting options: http://docs.python.org/lib/typesseq-strings.html		# string formatting options: http://docs.python.org/lib/typesseq-strings.html
	code = "%02x" % pattern		code = "%02x" % pattern
	patternstring = ('\\x' + code).decode('string_escape')		patternstring = ('\\x' + code).decode('string_escape')
	~~padded~~ = ~~toPad + patternstring*(~~self.blockSize - len(toPad)%self.blockSize)		amount = self.blockSize - len(toPad)%self.blockSize
			pad = ''.join(patternstring for x in range(0,amount))
			#pad = patternstring*(self.blockSize - len(toPad)%self.blockSize)
	else:		else:
	# no padding needed		# no padding needed
	~~padded~~ = ~~toPad~~		pad = ''
	return ~~padded~~		return toPad + pad

	def __PKCS7_unpad (self, padded ):		def __PKCS7_unpad (self, padded ):
Line 237:		Line 276:
	trail = "%02x" % bytesToPad		trail = "%02x" % bytesToPad
	pattern = '\x00'*(bytesToPad -1) + ('\\x' + trail).decode('string_escape')		pattern = '\x00'*(bytesToPad -1) + ('\\x' + trail).decode('string_escape')
	~~padded =~~ toPad + pattern		return toPad + pattern
	return padded

	def __ANSI_X923_unpad (self, padded ):		def __ANSI_X923_unpad (self, padded ):
Line 244:		Line 282:
	flag = 0		flag = 0
	#check if the bytes to be removed are all zero		#check if the bytes to be removed are all zero
	for i in ~~range(1,~~length + 1):		for x in padded[-length:-1]:
	if ~~padded[-i]~~ <> ~~'\x00'~~:		if int(hexlify(x),16) <> 0:
	flag = 1		flag = 1
	if flag == 0:		if flag == 0:
Line 253:		Line 291:
	print 'error: padding pattern not recognized'		print 'error: padding pattern not recognized'
	return unpadded		return unpadded

			def __ISO_10126 (self, toPad):
			bytesToPad = self.blockSize - len(toPad)%self.blockSize
			pattern1 = ''.join(("\\x%02x" % random.randint(0,255)).decode('string_escape') for x in range(0,bytesToPad-1))
			pattern2 = ("\\x%02x" % bytesToPad).decode('string_escape')
			return toPad + pattern1 + pattern2

			def __ISO_10126_unpad (self, padded):
			return padded[0:len(padded)-int(hexlify(padded[-1]),16)]


	if __name__ == "__main__":		if __name__ == "__main__":
Line 267:		Line 315:
	print "Test OK!"		print "Test OK!"
	else:		else:
	print "Test not OK!"		print "Test not OK!"
	</source>		</source>
	Download code: [{{#filelink: padding.py}} padding.py]		Download code: [{{#filelink: padding.py}} padding.py]

Tiftof: added padding.py

2008-08-21T14:06:59Z

added padding.py

← Older revision		Revision as of 14:06, 21 August 2008
Line 124:		Line 124:
	#1.38 µs per loop		#1.38 µs per loop
	</source>		</source>

			==Learning Python==
			Some code to make some padding functions available. The code is used as a way to learn python, so it contains things that don't make sense or could be done better.
			{{#fileanchor: padding.py}}
			<source lang=python>
			from binascii import hexlify

			class BlockOperator:
			"""Class for BlockOperator

			Only holds a variable blocksize. Class only exist for testing purpose.
			"""
			def __init__(self, bs=8):
			self.blockSize = bs

			class Padding(BlockOperator):
			"""Class for padding functions

			Inherits from the BlockOperator class

			padding info here: http://en.wikipedia.org/wiki/Padding_(cryptography)

			Example:
			from padding import *
			padder = Padding()
			padded = padder.pad('test','bitpadding)
			padder.unpad(padded,'bitpadding)
			"""

			def pad (self, toPad, algo):
			#there is no switch statement in python
			#discussion with alternatives: http://simonwillison.net/2004/May/7/switch/
			if algo == 'bitpadding':
			return self.__bitPadding(toPad)
			elif algo == 'zerospadding':
			return self.__zerosPadding(toPad)
			elif algo == 'PKCS7':
			return self.__PKCS7(toPad)
			elif algo == 'ANSI_X923':
			return self.__ANSI_X923(toPad)
			raise NotImplementedError()

			def unpad (self, toPad, algo):
			if algo == 'bitpadding':
			return self.__bitPadding_unpad(toPad)
			elif algo == 'zerospadding':
			return self.__zerosPadding_unpad(toPad)
			elif algo == 'PKCS7':
			return self.__PKCS7_unpad(toPad)
			elif algo == 'ANSI_X923':
			return self.__ANSI_X923_unpad(toPad)
			raise NotImplementedError()

			def __bitPadding (self, toPad ):
			if 0 <> len(toPad)%self.blockSize:
			padded = toPad + '\x80' + '\x00'*(self.blockSize - len(toPad)%self.blockSize -1)
			else:
			padded = toPad
			return padded

			def __bitPadding_unpad (self, padded ):
			return padded.rstrip('\x80' + '\x00')

			def __zerosPadding (self, toPad ):
			if 0 <> len(toPad)%self.blockSize:
			padded = toPad + '\x00'*(self.blockSize - len(toPad)%self.blockSize)
			else:
			padded = toPad
			return padded

			def __zerosPadding_unpad (self, padded ):
			# info on rstrip and other string methods: http://docs.python.org/lib/string-methods.html
			return padded.rstrip('\x00')

			def __PKCS7 (self, toPad ):
			"""Pad a binary string

			Input:
			toPad: binary string to be padded
			self.blockSize: the padded result will be a multiple of the self.blockSize(default=8)
			Output:
			return a binary string
			"""
			if 0 <> len(toPad)%self.blockSize:
			pattern = self.blockSize - len(toPad)%self.blockSize
			# 0 -> zero padding for numeric values; 2 -> length modifier; x -> hex output
			# string formatting options: http://docs.python.org/lib/typesseq-strings.html
			code = "%02x" % pattern
			patternstring = ('\\x' + code).decode('string_escape')
			padded = toPad + patternstring*(self.blockSize - len(toPad)%self.blockSize)
			else:
			# no padding needed
			padded = toPad
			return padded

			def __PKCS7_unpad (self, padded ):
			pattern = padded[-1]
			length = int(hexlify(pattern),16)
			flag = 0
			for i in range(1,length + 1):
			if padded[-i] <> pattern:
			flag = 1
			if flag == 0:
			unpadded = padded[:-length]
			else:
			unpadded = padded
			print 'error: padding pattern not recognized'
			return unpadded

			def __ANSI_X923 (self, toPad ):
			bytesToPad = self.blockSize - len(toPad)%self.blockSize
			trail = "%02x" % bytesToPad
			pattern = '\x00'*(bytesToPad -1) + ('\\x' + trail).decode('string_escape')
			padded = toPad + pattern
			return padded

			def __ANSI_X923_unpad (self, padded ):
			length = int(hexlify(padded[-1]),16)
			flag = 0
			#check if the bytes to be removed are all zero
			for i in range(1,length + 1):
			if padded[-i] <> '\x00':
			flag = 1
			if flag == 0:
			unpadded = padded[:-length]
			else:
			unpadded = padded
			print 'error: padding pattern not recognized'
			return unpadded

			if __name__ == "__main__":
			#only executed when module is run by: "python padding.py"
			from padding import *
			padder = Padding()
			toPad = 'test'
			print "String to be padded: %r" % toPad
			padded = padder.pad(toPad,'bitpadding')
			print "padded: %r" % padded
			unpadded = padder.unpad(padded,'bitpadding')
			print "unpadded: %r" % unpadded
			if unpadded == toPad:
			print "Test OK!"
			else:
			print "Test not OK!"
			</source>
			Download code: [{{#filelink: padding.py}} padding.py]

PhilippeTeuwen: /* Helper functions */

2008-08-20T16:00:41Z

Helper functions

← Older revision		Revision as of 16:00, 20 August 2008
Line 2:		Line 2:

	==Helper functions==		==Helper functions==
	Conversion from int or long to raw string and back is [http://bugs.python.org/issue1023290 discussed on the Python bug tracking list] but since the problem is not yet solved, let's see how to make our own helper functions in a clean and fast way:		Conversion from int or long to raw string and back is [http://bugs.python.org/issue1023290 discussed on the Python bug tracking list] but since the problem is not yet solved, let's see how to make our own helper functions in a clean and fast way: (measures with %timeit of ipython)
	<source lang=python>		<source lang=python>
	############################### long2string ########################################		############################### long2string ########################################
Line 26:		Line 26:
	long2string(1234567890123456789012345)		long2string(1234567890123456789012345)
	#16.4 µs per loop		#16.4 µs per loop
			###################################################################################
			def long2string(i):
			return ''.join([chr(i>>j & 0xFF) for j in range(int(math.log(i,2)//8)<<3,-1,-8)])
			long2string(123456789012345678901234)
			#15.5 µs per loop
			long2string(1234567890123456789012345)
			#16.7 µs per loop
	###################################################################################		###################################################################################
	import math		import math

PhilippeTeuwen: New page: Back to SAGE & cryptology ==Helper functions== Conversion from int or long to raw string and back is [http://bugs.python.org/issue1023290 discussed on the Python bug tracking list] bu...

2008-08-18T14:05:20Z

New page: Back to SAGE & cryptology ==Helper functions== Conversion from int or long to raw string and back is [http://bugs.python.org/issue1023290 discussed on the Python bug tracking list] bu...

New page

Back to [[SAGE & cryptology]]

==Helper functions==
Conversion from int or long to raw string and back is [http://bugs.python.org/issue1023290 discussed on the Python bug tracking list] but since the problem is not yet solved, let's see how to make our own helper functions in a clean and fast way:
<source lang=python>
############################### long2string ########################################
def long2string(i):
l=[]
while i:
l[0:0]=chr(i&0xff)
i=i>>8
return ''.join(l)
long2string(123456789012345678901234)
#46 µs per loop
long2string(1234567890123456789012345)
#51.8 µs per loop
###################################################################################
def long2string(i):
l=[]
while i:
l.append(chr(i&0xff))
i=i>>8
return ''.join(l[::-1])
long2string(123456789012345678901234)
#15.1 µs per loop
long2string(1234567890123456789012345)
#16.4 µs per loop
###################################################################################
import math
def long2string(i):
return binascii.unhexlify('%0*x' % (int(math.ceil(math.log(i,2)/8)*2) , i))
long2string(123456789012345678901234)
#4.77 µs per loop
long2string(1234567890123456789012345)
#4.83 µs per loop
###################################################################################
def long2string(i):
return binascii.unhexlify('%0*x' % (len(hex(i)) & -2 , i)).lstrip('\x00')
long2string(123456789012345678901234)
#3.64 µs per loop
long2string(1234567890123456789012345)
#3.78 µs per loop
###################################################################################
binascii.unhexlify('%0*x' % (32 , 123456789012345678901234))
#2.06 µs per loop
binascii.unhexlify('%0*x' % (32 , 1234567890123456789012345))
#2.01 µs per loop
#Ok if you want fixed length buffer, e.g. 32 bytes
###################################################################################
def long2string(i):
s=hex(i)[2:].rstrip('L')
if len(s) % 2:
s='0'+s
return binascii.unhexlify(s)
long2string(123456789012345678901234)
#2.88 µs per loop
long2string(1234567890123456789012345)
#3.22 µs per loop
###################################################################################
def long2string(i):
s='0'+hex(long(i))[2:-1]
return binascii.unhexlify(s[len(s) % 2:])
long2string(123456789012345678901234)
#3.04 µs per loop
long2string(1234567890123456789012345)
#3.03 µs per loop
###################################################################################
def long2string(i):
s=hex(long(i))[2:-1]
if len(s) % 2:
s='0'+s
return binascii.unhexlify(s)
long2string(123456789012345678901234)
#2.75 µs per loop
long2string(1234567890123456789012345)
#3.06 µs per loop
###################################################################################
#If we are sure our argument is a long we can remove the cast in the 2 previous codes:
def long2string(i):
s='0'+hex(i)[2:-1]
return binascii.unhexlify(s[len(s) % 2:])
long2string(123456789012345678901234)
#2.66 µs per loop
long2string(1234567890123456789012345)
#2.62 µs per loop
###################################################################################
def long2string(i):
s=hex(i)[2:-1]
if len(s) % 2:
s='0'+s
return binascii.unhexlify(s)
long2string(123456789012345678901234)
#2.42 µs per loop
long2string(1234567890123456789012345)
#2.76 µs per loop
###################################################################################
# There is still room ;-)
binascii.unhexlify('1a249b1f10a06c96aff2')
#990 ns per loop
###################################################################################
############################### string2long ########################################
def string2long(s):
i=0
for c in s:
i=(i<<8)+ord(c)
return i
string2long('\x01\x05n\x0f6\xa6D=\xe2\xdfy')
#8.91 µs per loop
###################################################################################
int('\x01\x05n\x0f6\xa6D=\xe2\xdfy'.encode('hex'),16)
#3.15 µs per loop
###################################################################################
int(binascii.hexlify('\x01\x05n\x0f6\xa6D=\xe2\xdfy'),16)
#1.64 µs per loop
###################################################################################
long(binascii.hexlify('\x01\x05n\x0f6\xa6D=\xe2\xdfy'),16)
#1.38 µs per loop
</source>