Python DSA.load_key_bio方法代码示例

# 需要导入模块: from M2Crypto import DSA [as 别名]
# 或者: from M2Crypto.DSA import load_key_bio [as 别名]
def parse_priv_key(privstr):
    if not isinstance(privstr, str):
        raise TypeError('str argument required')
    if not privstr.startswith('-----BEGIN DSA PRIVATE KEY-----') \
            and not privstr.startswith('-----BEGIN RSA PRIVATE KEY-----'):
        raise ValueError("public key didn't start with '-----BEGIN ANY PRIVATE KEY-----'")
    mem = BIO.MemoryBuffer(privstr)
    return DSA.load_key_bio(mem)

# 需要导入模块: from M2Crypto import DSA [as 别名]
# 或者: from M2Crypto.DSA import load_key_bio [as 别名]
	def payment_pta(self):
		'''Generates the Payment Transaction Authorization, or PTA. It does not communicate with the server.'''

		#------------------------------------
		#        PTA Payment Block
		#------------------------------------
		p1 = pcos.create_output_block( 'P1' )

		# member authentication token
		mat = self.args['mat'] 
		if len( mat ) != 40:
			raise RuntimeError("MAT must be 40-characters long" % self.cmd)
		p1.write_varstr( binascii.unhexlify( mat ) )

		# cert. create time and expiry
		now = long( time.time() + 0.5 )
		p1.write_ulong( now ) # certificate create-time
		p1.write_ulong( now + 24 * 3600 ) # certificate expires in 24 hrs

		# payment-limit
		(payment_int, payment_scale) = decimal_to_parts(Decimal(self.args['limit']))
		p1.write_long( payment_int ) # value
		p1.write_int( payment_scale ) # scale

		# currency
		p1.write_fixstr( "USD", size=3 )

		# recipient
		p1.write_varstr( "" )

		# ref-data
		p1.write_varstr( "" )

		# note
		p1.write_varstr( "" )

		print (" %s bytes => Payment Block" % p1.size())

		#------------------------------------
		#        PTA Signature Block
		#------------------------------------
		s1 = pcos.create_output_block( 'S1' )

		# checksum Payment Block
		digest = hashlib.sha1(p1.as_bytearray()).digest()
		
		# sign the checksum
		dsa_priv_key = BIO.MemoryBuffer( TEST_DSA_KEY_PRV_PEM )
		signer = DSA.load_key_bio( dsa_priv_key )
		signature = signer.sign_asn1( digest )

		# store the signature of the Payment Block
		s1.write_varstr( signature )
		print (" %s bytes => Signature Block" % s1.size())

		#------------------------------------
		# PTA Message
		#  * Payment Block
		#  * Signature Block
		#------------------------------------
		pta = pcos.Doc( name="Pa" )
		pta.add( p1 )
		pta.add( s1 )

		#------------------------------------
		#    A-PTA Private (PTA) Block
		#------------------------------------
		a1 = pcos.create_output_block( 'A1' )
		
		# encrypt the PTA message
		txn_pub_key = BIO.MemoryBuffer( API_TRANSACTION_KEY_PEM )
		encrypter = RSA.load_pub_key_bio( txn_pub_key )
		# RSA Encryption Scheme w/ Optimal Asymmetric Encryption Padding
		input_data = pta.as_bytearray()
		print (" %s bytes => header+meta" % (len(input_data) - s1.size() - p1.size()))
		print ("-------------\n %s bytes => Total PTA\n---------" % len(input_data))
		encrypted = encrypter.public_encrypt( pta.as_bytearray(), RSA.pkcs1_padding )
		a1.write_fixstr( encrypted, size=len(encrypted) )

		#------------------------------------
		#    A-PTA Public Block
		#------------------------------------
		k1 = pcos.create_output_block( 'K1' )
		# encryption key identifier
		k1.write_fixstr( API_TRANSACTION_KEY_ID, size=len(API_TRANSACTION_KEY_ID) )

		#------------------------------------
		#    A-PTA Message
		#------------------------------------
		apta = pcos.Doc( name="Ap" )
		apta.add( a1 )
		apta.add( k1 )
		apta_bytes = apta.as_bytearray()

		# write serialized data as binary and qr-code
		payload_file = open('apta.pcos', 'w')
		payload_file.write( apta_bytes )
		payload_file.close()
		print ("Saved APTA object to 'apta.pcos'")

#.........这里部分代码省略.........

# 需要导入模块: from M2Crypto import DSA [as 别名]
# 或者: from M2Crypto.DSA import load_key_bio [as 别名]
	def charge(self, payment_type, payment_bytes):
		#------------------------------------
		#      Payment Block
		#------------------------------------
		payment_block = pcos.create_output_block( payment_type )

		# we use "fixstr" becase we don't want size-prefix
		payment_block.write_fixstr(payment_bytes, len(payment_bytes))

		#------------------------------------
		#      Payment Request Block
		#------------------------------------
		paymnt_req_block = pcos.create_output_block( 'R1' ) 

		# mat
		paymnt_req_block.write_varstr( binascii.unhexlify( self.args['receiver_mat'] ) )

		# ref data
		paymnt_req_block.write_varstr( '' )

		# create-time
		paymnt_req_block.write_ulong( long( time.time() + 0.5 ) )

		(charge_int, charge_scale) = decimal_to_parts(Decimal(self.args['charge']))
		paymnt_req_block.write_long( charge_int ) # value
		paymnt_req_block.write_int( charge_scale ) # scale

		# tax
		paymnt_req_block.write_bool(True) # optional indicator
		(tax_value, tax_scale) = decimal_to_parts(Decimal(self.args['tax']))
		paymnt_req_block.write_long( tax_value ) # value
		paymnt_req_block.write_int( tax_scale ) # scale

		# tip
		paymnt_req_block.write_bool(True) # optional indicator
		(tip_value, tip_scale) = decimal_to_parts(Decimal(self.args['tip']))
		paymnt_req_block.write_long( tip_value ) # value
		paymnt_req_block.write_int( tip_scale ) # scale

		# currency
		paymnt_req_block.write_fixstr( "USD", size=3 )

		# invoice ID
		paymnt_req_block.write_varstr( 'inv-123' )

		# note
		paymnt_req_block.write_varstr( 'happy meal' )

		# no geo-location available
		paymnt_req_block.write_bool(False)

		# list of purchased goods
		paymnt_req_block.write_int(0)

		#------------------------------------
		#   Payment Request Signature Block
		#------------------------------------

		paymnt_req_signature_block = pcos.create_output_block( 'S1' )

		# checksum Payment Request Block
		digest = hashlib.sha1(paymnt_req_block.as_bytearray()).digest()
		
		# sign the checksum
		dsa_priv_key = BIO.MemoryBuffer( TEST_DSA_KEY_PRV_PEM )
		signer = DSA.load_key_bio( dsa_priv_key )
		signature = signer.sign_asn1( digest )

		# store the signature of the Payment Block
		paymnt_req_signature_block.write_varstr( signature )

		#------------------------------------
		#      Payment Request Message
		#------------------------------------
		req = pcos.Doc( name="Pt" )
		req.add( paymnt_req_block )
		req.add( paymnt_req_signature_block )
		req.add( payment_block )

		res = self.send( req )
		
		# there can be two types of results: Ap or Np, depending
		# success or failure due to insufficient funds
		if res.message_id != 'Ap' and res.message_id != 'Np':
			raise RuntimeError("Unexpected payment result '%s'" % res.message_id)
		
		# read balance
		balance = res.block( 'Bo' )
		ref_data = balance.read_varstr() # ref_data
		transaction_id = balance.read_varstr() # tx-id

		if res.message_id == 'Np':
			code = er.read_uint()
			what = er.read_varstr()
			
		# exact amount given?
		if balance.read_bool():
			exact_balance = 'is'
		else:
			exact_balance = 'is greater than' 
#.........这里部分代码省略.........

# 需要导入模块: from M2Crypto import DSA [as 别名]
# 或者: from M2Crypto.DSA import load_key_bio [as 别名]
	def payment(self):
		'''This command generates the Payment Transaction Authorization, or PTA. It does not communicate with the server, only produces a file.'''

		#------------------
		# PTA public-block
		#------------------
		p1 = pcos.Block( 'P1', 512, 'O' )
		now = long( time.time() + 0.5 )
		p1.write_int64( now ) # certificate create-time
		p1.write_int64( now + 24 * 3600 ) # certificate expiry (in 24 hrs)
		# p1.write_int64( now + 60*2 ) # certificate expiry

		# payment-limit
		(payment_int, payment_scale) = decimal_to_parts(Decimal(self.args['limit']))
		p1.write_int64( payment_int ) # value
		p1.write_int16( payment_scale ) # scale

		# gratuity
		tip = tip_type = None
		tipv = self.args.get('tip_pct', None)
		if tipv:
			tip_type = 'P'
		else:
			tipv = self.args.get('tip_abs', None)
			if tipv:
				tip_type = 'A'

		if tipv:
			(tip_int, tip_scale) = decimal_to_parts(Decimal(tipv))
			p1.write_byte(1) # optional indicator
			p1.write_fixed_string(tip_type, size=1) # tip type (P or A)
			p1.write_int64( tip_int ) # value
			p1.write_int16( tip_scale ) # scale
		else:
			p1.write_byte(0) # optional indicator -- no tip

		p1.write_fixed_string( "USD", size=3 ) # currency
		p1.write_fixed_string( binascii.unhexlify( API_TRANSACTION_KEY_ID ), size=4 ) # key-ID

		p1.write_short_string( '', max=127 ) # receiver
		p1.write_short_string( '', max=127 ) # note

		#-------------------
		# PTA private-block
		#-------------------
		priv = pcos.Block( 'S1', 512, 'O' )

		# member authentication token
		mat = self.args['mat'] 
		if len( mat ) != 40:
			raise RuntimeError("MAT must be 40-characters long" % self.cmd)
		priv.write_fixed_string( binascii.unhexlify( self.args['mat'] ), size=20 ) # mat
		priv.write_short_string( '', max=20 ) # ref-data
		
		# sign the public-block
		#   * first, produce the checksum
		digest = hashlib.sha1(str(p1)).digest()
		
		#   * then sign the checksum
		dsa_priv_key = BIO.MemoryBuffer( TEST_DSA_KEY_PRV_PEM )
		signer = DSA.load_key_bio( dsa_priv_key )
		signature = signer.sign_asn1( digest )
		priv.write_short_string( signature, max=48 ) # signature of the pub block
		priv.write_short_string( '', max=20 ) # empty user data

		# encrypt the private-block
		txn_pub_key = BIO.MemoryBuffer( API_TRANSACTION_KEY_PEM )
		encrypter = RSA.load_pub_key_bio( txn_pub_key )
		# RSA Encryption Scheme w/ Optimal Asymmetric Encryption Padding
		encrypted = encrypter.public_encrypt( str(priv), RSA.pkcs1_oaep_padding )

		# At this point we no longer need the private object. We only attach the
		# encrypted instance.
		s1 = pcos.Block( 'S1', 512, 'O' )
		s1.write_fixed_string( encrypted, size=128 )

		#-------------------
		# PTA envelope
		#-------------------
		env = pcos.Doc( name="Pa" )
		# order in which we add blocks doesn't matter
		env.add( p1 )
		env.add( s1 )

		# write serialized data as binary and qr-code
		encoded = env.encoded()
		reqf = open('pta.pcos', 'w')
		reqf.write( encoded )
		reqf.close()
		print ("Saved PTA object to 'pta.pcos'")

		# optionally generate qr-code
		try:
			import qrcode
			qr = qrcode.QRCode(version=None, box_size=3, error_correction=qrcode.constants.ERROR_CORRECT_L)
			qr.add_data( encoded )
			qr.make(fit=True)
			img = qr.make_image()
			img.save('pta.png')
			print ("PTA-QR: pta.png, version %s" % (qr.version))
#.........这里部分代码省略.........