示例#1
0
 def can_spent(self):
     for input in self.inputs:
         print(input)
         print(input.hash)
         if not bitcoin.ecdsa_verify(bitcoin.sha256(str(input)), input.sign,
                                     input.pubk):
             raise Exception()
示例#2
0
	def auth_counterparty(self, nick, btc_sig, cj_pub):
		'''Validate the counterpartys claim to own the btc
		address/pubkey that will be used for coinjoining 
		with an ecdsa verification.'''
		if not btc.ecdsa_verify(self.crypto_boxes[nick][0], btc_sig, cj_pub):
			print 'signature didnt match pubkey and message'
			return False
		return True
示例#3
0
    def auth_counterparty(self, nick, btc_sig, cj_pub):
        '''Validate the counterpartys claim to own the btc
		address/pubkey that will be used for coinjoining 
		with an ecdsa verification.'''
        if not btc.ecdsa_verify(self.crypto_boxes[nick][0], btc_sig, cj_pub):
            print 'signature didnt match pubkey and message'
            return False
        return True
示例#4
0
def verify(challenge_hidden, challenge_visual, pubkey, signature, version):
    if version == 1:
        message = binascii.unhexlify(challenge_hidden +
                                     binascii.hexlify(challenge_visual))
    elif version == 2:
        h1 = hashlib.sha256(binascii.unhexlify(challenge_hidden)).digest()
        h2 = hashlib.sha256(challenge_visual).digest()
        message = h1 + h2
    else:
        raise Exception('Unknown version')
    signature_b64 = base64.b64encode(binascii.unhexlify(signature))
    return bitcoin.ecdsa_verify(message, signature_b64, pubkey)
示例#5
0
def validate_sig(sig, msg, address, type="transaction"):
    try:
        pubkey = ecdsa_recover(msg, sig)
    except:
        raise InvalidSignature("Can't recover pubkey from %s signature" % type)

    valid_sig = ecdsa_verify(msg, sig, pubkey)
    valid_address = pubtoaddr(pubkey) == address

    if not valid_sig or not valid_address:
        raise InvalidSignature("%s signature not valid" % type.title())

    return True
示例#6
0
 def auth_counterparty(self, nick, btc_sig, auth_pub):
     """Validate the counterpartys claim to own the btc
     address/pubkey that will be used for coinjoining
     with an ecdsa verification.
     Note that this is only a first-step
     authorisation; it checks the btc signature, but
     the authorising pubkey is checked to be part of the
     transactoin in recv_txio.
     """
     if not btc.ecdsa_verify(self.crypto_boxes[nick][0], btc_sig, auth_pub):
         log.debug('signature didnt match pubkey and message')
         return False
     return True
示例#7
0
 def auth_counterparty(self, nick, btc_sig, auth_pub):
     """Validate the counterpartys claim to own the btc
     address/pubkey that will be used for coinjoining
     with an ecdsa verification.
     Note that this is only a first-step
     authorisation; it checks the btc signature, but
     the authorising pubkey is checked to be part of the
     transactoin in recv_txio.
     """
     if not btc.ecdsa_verify(self.crypto_boxes[nick][0], btc_sig, auth_pub):
         log.debug('signature didnt match pubkey and message')
         return False
     return True
示例#8
0
def save_memo(request):
    encrypted_text = request.POST['encrypted_text']
    pubkey = request.POST['pubkey']
    sig = request.POST['signature']
    txid = request.POST['txid'].lower()
    crypto = request.POST.get('currency', 'btc').lower()

    if len(encrypted_text) > settings.MAX_MEMO_SIZE_BYTES:
        return http.JsonResponse(
            {
                'error':
                "Memo exceeds maximum size of: %s bytes" %
                settings.MAX_MEMO_SIZE_BYTES
            },
            status=400)

    data = dict(pubkey=pubkey,
                crypto=crypto,
                txid=txid,
                encrypted_text=encrypted_text)
    if Memo.objects.filter(**data).exists():
        return http.HttpResponse("OK")
    data['signature'] = sig

    try:
        version_byte = crypto_data[crypto]['address_version_byte']
    except IndexError:
        return http.HttpResponse("Currency not supported", status=400)

    address = pubkey_to_address(pubkey, version_byte)
    tx = CachedTransaction.fetch_full_tx(crypto, txid=txid)

    for item in tx['inputs'] + tx['outputs']:
        if item['address'] == address:
            break
    else:
        return http.HttpResponse("Pubkey not in TXID", status=400)

    if ecdsa_verify(encrypted_text, sig, pubkey):
        memo, c = Memo.objects.get_or_create(crypto=crypto,
                                             txid=txid,
                                             pubkey=pubkey)
        memo.encrypted_text = encrypted_text
        memo.signature = sig
        memo.save()
    else:
        return http.HttpResponse("Invalid signature", status=400)

    return http.HttpResponse("OK")
示例#9
0
	def auth_counterparty(self, nick, i_utxo_pubkey, btc_sig):
		self.i_utxo_pubkey = i_utxo_pubkey
		
		if not btc.ecdsa_verify(self.taker_pk, btc_sig, self.i_utxo_pubkey):
			print 'signature didnt match pubkey and message'
			return False
		#authorisation of taker passed 
		#(but input utxo pubkey is checked in verify_unsigned_tx).
		#Send auth request to taker
		#TODO the next 2 lines are a little inefficient.
		btc_key = self.maker.wallet.get_key_from_addr(self.cj_addr)
		btc_pub = btc.privtopub(btc_key)
		btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), btc_key)
		self.maker.msgchan.send_ioauth(nick, self.utxos.keys(), btc_pub, self.change_addr, btc_sig)
		return True
示例#10
0
 def verify_nick(self, nick, sig, message):
     if not btc.ecdsa_verify(message + str(self.hostid), sig[1], sig[0]):
         log.debug("nick signature verification failed, ignoring.")
         return False
     #check that nick matches hash of pubkey
     nick_pkh_raw = hashlib.sha256(sig[0]).digest()[:NICK_HASH_LENGTH]
     nick_stripped = nick[2:2+NICK_MAX_ENCODED]
     #strip right padding
     nick_unpadded = ''.join([x for x in nick_stripped if x != 'O'])
     if not nick_unpadded == btc.changebase(nick_pkh_raw, 256, 58):
         log.debug("Nick hash check failed, expected: " + str(
             nick_unpadded) + ", got: " + str(
                 btc.changebase(nick_pkh_raw, 256, 58)))
         return False
     return True
示例#11
0
def validate_peer_registration(reg, now=None):
    ts = dateutil.parser.parse(reg['timestamp'])
    validate_timestamp(ts, now=now)

    to_sign = "{domain}{payout_address}{timestamp}".format(**reg)
    try:
        pubkey = ecdsa_recover(to_sign, reg['signature'])
    except:
        raise InvalidSignature("Can't recover pubkey from signature")

    valid_address = pubtoaddr(pubkey) == reg['payout_address']
    valid_sig = ecdsa_verify(to_sign, reg['signature'], pubkey)

    if not valid_sig or not valid_address:
        raise InvalidSignature("Invalid Signature")
    return True
示例#12
0
def save_memo(request):
    encrypted_text = request.POST['encrypted_text']
    pubkey = request.POST['pubkey']
    sig = request.POST['signature']
    txid = request.POST['txid'].lower()
    crypto = request.POST.get('currency', 'btc').lower()

    if len(encrypted_text) > settings.MAX_MEMO_SIZE_BYTES:
        return http.JsonResponse(
            {'error': "Memo exceeds maximum size of: %s bytes" % settings.MAX_MEMO_SIZE_BYTES},
            status=400
        )

    data = dict(pubkey=pubkey, crypto=crypto, txid=txid, encrypted_text=encrypted_text)
    if Memo.objects.filter(**data).exists():
        return http.HttpResponse("OK")
    data['signature'] = sig

    try:
        version_byte = crypto_data[crypto]['address_version_byte']
    except IndexError:
        return http.HttpResponse("Currency not supported", status=400)

    address = pubkey_to_address(pubkey, version_byte)
    tx = CachedTransaction.fetch_full_tx(crypto, txid=txid)

    for item in tx['inputs'] + tx['outputs']:
        if item['address'] == address:
            break
    else:
        return http.HttpResponse("Pubkey not in TXID", status=400)

    if ecdsa_verify(encrypted_text, sig, pubkey):
        memo, c = Memo.objects.get_or_create(
            crypto=crypto,
            txid=txid,
            pubkey=pubkey
        )
        memo.encrypted_text = encrypted_text
        memo.signature = sig
        memo.save()
    else:
        return http.HttpResponse("Invalid signature", status=400)

    return http.HttpResponse("OK")
示例#13
0
def validate_transaction(tx, ledger=None, min_fee=0.01, now=None):
    """
    Validates that the passed in transaction object is valid in terms of
    cryptography. UTXO validation does not happen here.
    `ledger` is a callable that returns the address's balance and last spend timestamp.
    """
    ts = dateutil.parser.parse(tx['timestamp'])
    out_total, out_msg = _process_outputs(tx['outputs'], ts)
    validate_timestamp(ts, now=now)

    in_total = 0
    for i, input in enumerate(tx['inputs']):
        address, amount, sig = input
        amount = _cut_to_8(amount)
        if amount <= 0:
            raise InvalidAmounts("Input %s can't be zero or negative" % i)

        message = "%s%s%s" % (address, amount, out_msg)
        in_total += amount
        try:
            pubkey = ecdsa_recover(message, sig)
        except:
            raise InvalidSignature("Signature %s not valid" % i)

        if ledger:
            address_balance, last_spend = ledger(address)
            delt = datetime.timedelta(seconds=PROPAGATION_WINDOW_SECONDS)
            if last_spend + delt > ts:
                raise InvalidTransaction("Input too young")
            if address_balance < amount:
                raise InvalidAmounts("Not enough balance in %s" % address)

        valid_sig = ecdsa_verify(message, sig, pubkey)
        valid_address = pubtoaddr(pubkey) == address
        if not valid_sig or not valid_address:
            raise InvalidSignature("Signature %s not valid" % i)

    if in_total < out_total:
        raise InvalidAmounts("Input amount does not exceed output amount")

    fee = in_total - out_total
    if fee < min_fee:
        raise InvalidFee("Fee of %.8f below min fee of %.8f" % (fee, min_fee))

    return True
示例#14
0
    def verify_multisig(self, controller_pubkeys):
        #function to verify the signatures of the object against the policy
        #and supplied public key list: returns validity
        nsig = len(self.map["sigs"])
        if nsig < self.map["n"]:
            print("Error: insufficient signatures")
            return False
#the signature is generated over the asset list json object concatinated with the policy and time
        jsonstring = json.dumps(self.map["assets"], sort_keys=True)
        jsonstring += str(self.map["n"]) + str(self.map["m"]) + str(
            self.map["time"]) + str(self.map["height"])
        nvalid = 0
        #check all possible combinations of public keys and signatures
        for key in controller_pubkeys:
            for i, j in self.map["sigs"].items():
                if bc.ecdsa_verify(jsonstring, j, key): nvalid += 1
        if nvalid >= self.map["n"]:
            return True
        else:
            return False