def get_harvester_signature(self, header_data: HeaderData, plot_pk: PublicKey): for value_dict in self.plot_config["plots"].values(): if (PrivateKey.from_bytes(bytes.fromhex( value_dict["sk"])).get_public_key() == plot_pk): return PrivateKey.from_bytes(bytes.fromhex( value_dict["sk"])).sign_prepend(header_data.get_hash())
def test_threshold_instance(T, N): commitments = [] # fragments[i][j] = fragment held by player i, # received from player j fragments = [[None] * N for _ in range(N)] secrets = [] # Step 1 : Threshold.create for player in range(N): secret_key, commi, frags = Threshold.create(T, N) for target, frag in enumerate(frags): fragments[target][player] = frag commitments.append(commi) secrets.append(secret_key) # Step 2 : Threshold.verify_secret_fragment for player_source in range(1, N + 1): for player_target in range(1, N + 1): assert Threshold.verify_secret_fragment( player_target, fragments[player_target - 1][player_source - 1], commitments[player_source - 1], T) # Step 3 : master_pubkey = PublicKey.aggregate_insecure(...) # secret_share = PrivateKey.aggregate_insecure(...) master_pubkey = PublicKey.aggregate_insecure( [commitments[i][0] for i in range(N)]) secret_shares = [ PrivateKey.aggregate_insecure(fragment_row) for fragment_row in fragments ] master_privkey = PrivateKey.aggregate_insecure(secrets) msg = ("Test").encode("utf-8") signature_actual = master_privkey.sign_insecure(msg) # Step 4 : sig_share = Threshold.sign_with_coefficient(...) # Check every combination of T players for X in combinations(range(1, N + 1), T): # X: a list of T indices like [1, 2, 5] # Check signatures signature_shares = [ Threshold.sign_with_coefficient(secret_shares[x - 1], msg, x, X) for x in X ] signature_cand = InsecureSignature.aggregate(signature_shares) assert signature_cand == signature_actual # Check that the signature actually verifies the message assert signature_actual.verify([Util.hash256(msg)], [master_pubkey]) # Step 4b : Alternatively, we can add the lagrange coefficients # to 'unit' signatures. for X in combinations(range(1, N + 1), T): # X: a list of T indices like [1, 2, 5] # Check signatures signature_shares = [secret_shares[x - 1].sign_insecure(msg) for x in X] signature_cand = Threshold.aggregate_unit_sigs(signature_shares, X) assert signature_cand == signature_actual
def test_vectors4(): sk1 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5])) sk2 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5, 6])) pk1 = sk1.get_public_key() pk2 = sk2.get_public_key() m1 = bytes([7, 8, 9]) m2 = bytes([10, 11, 12]) sig9 = sk1.sign_prepend(m1) sig10 = sk2.sign_prepend(m2) assert (sig9.serialize() == bytes.fromhex( "d2135ad358405d9f2d4e68dc253d64b6049a821797817cffa5aa804086a8fb7b135175bb7183750e3aa19513db1552180f0b0ffd513c322f1c0c30a0a9c179f6e275e0109d4db7fa3e09694190947b17d890f3d58fe0b1866ec4d4f5a59b16ed" )) assert (sig10.serialize() == bytes.fromhex( "cc58c982f9ee5817d4fbf22d529cfc6792b0fdcf2d2a8001686755868e10eb32b40e464e7fbfe30175a962f1972026f2087f0495ba6e293ac3cf271762cd6979b9413adc0ba7df153cf1f3faab6b893404c2e6d63351e48cd54e06e449965f08" )) agg_sig = PrependSignature.aggregate([sig9, sig9, sig10]) message_hashes = [Util.hash256(m1), Util.hash256(m1), Util.hash256(m2)] pks = [pk1, pk1, pk2] assert (agg_sig.serialize() == bytes.fromhex( "c37077684e735e62e3f1fd17772a236b4115d4b581387733d3b97cab08b90918c7e91c23380c93e54be345544026f93505d41e6000392b82ab3c8af1b2e3954b0ef3f62c52fc89f99e646ff546881120396c449856428e672178e5e0e14ec894" )) assert (agg_sig.verify(message_hashes, pks))
def create_transaction(): values = request.get_json() print(values) try: to = values.get("node") except: return jsonify("bad request, parameters not found"), 401 if to is None: to = "127.0.0.1:5001" seed = bytes([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]) from_sk = PrivateKey.from_seed(seed) from_pk = from_sk.get_public_key() amount = random.randint(1, 100) seed = [] for i in range(0, 32): seed.append(random.randint(0, 254)) seed = bytes(seed) to_sk = PrivateKey.from_seed(seed) to_pk = to_sk.get_public_key() tx = Transaction(str(from_pk.serialize(), "ISO-8859-1"), str(to_pk.serialize(), "ISO-8859-1"), amount, from_sk) print(tx.verify_signature()) url = "http://" + to + "/transactions/new" response = requests.post(url, json=tx.jsonify_Transaction()) print(response.status_code) return jsonify("transaction created and sent to destination"), 200
def calculate_synthetic_secret_key(secret_key: PrivateKey, hidden_puzzle_hash: bytes32) -> PrivateKey: secret_exponent = int.from_bytes(bytes(secret_key), "big") public_key = secret_key.get_g1() synthetic_offset = calculate_synthetic_offset(public_key, hidden_puzzle_hash) synthetic_secret_exponent = (secret_exponent + synthetic_offset) % GROUP_ORDER blob = synthetic_secret_exponent.to_bytes(32, "big") synthetic_secret_key = PrivateKey.from_bytes(blob) return synthetic_secret_key
def private_key_gen(seed=None): if seed == None: sk = PrivateKey.from_seed(seed_gen()) else: sk = PrivateKey.from_seed(seed) sk_bytes = sk.serialize() output_file = open(KEY_FILE_PATH, "wb") output_file.write(sk_bytes) output_file.close() return sk_bytes
def sign( self, privKey: blspy.PrivateKey, nonce: int ) -> None: self.holder = privKey.get_public_key().serialize() self.nonce = nonce self.blsSignature = privKey.sign(self.prefix + Verification.serialize(self)) self.signature = self.blsSignature.serialize()
def test_vectors2(): m1 = bytes([1, 2, 3, 40]) m2 = bytes([5, 6, 70, 201]) m3 = bytes([9, 10, 11, 12, 13]) m4 = bytes([15, 63, 244, 92, 0, 1]) sk1 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5])) sk2 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5, 6])) sig1 = sk1.sign(m1) sig2 = sk2.sign(m2) sig3 = sk2.sign(m1) sig4 = sk1.sign(m3) sig5 = sk1.sign(m1) sig6 = sk1.sign(m4) sig_L = Signature.aggregate([sig1, sig2]) sig_R = Signature.aggregate([sig3, sig4, sig5]) assert (sig_L.verify()) assert (sig_R.verify()) sig_final = Signature.aggregate([sig_L, sig_R, sig6]) assert (sig_final.serialize() == bytes.fromhex( "07969958fbf82e65bd13ba0749990764cac81cf10d923af9fdd2723f1e3910c3fdb874a67f9d511bb7e4920f8c01232b12e2fb5e64a7c2d177a475dab5c3729ca1f580301ccdef809c57a8846890265d195b694fa414a2a3aa55c32837fddd80" )) assert (sig_final.verify()) quotient = sig_final.divide_by([sig2, sig5, sig6]) assert (quotient.verify()) assert (sig_final.verify()) assert (quotient.serialize() == bytes.fromhex( "8ebc8a73a2291e689ce51769ff87e517be6089fd0627b2ce3cd2f0ee1ce134b39c4da40928954175014e9bbe623d845d0bdba8bfd2a85af9507ddf145579480132b676f027381314d983a63842fcc7bf5c8c088461e3ebb04dcf86b431d6238f" )) assert (quotient.divide_by([]) == quotient) try: quotient.divide_by([sig6]) assert (False) # Should fail due to not subset except: pass sig_final.divide_by([sig1]) # Should not throw try: sig_final.divide_by([sig_L]) # Should throw due to not unique assert (False) # Should fail due to not unique except: pass # Divide by aggregate sig7 = sk2.sign(m3) sig8 = sk2.sign(m4) sig_R2 = Signature.aggregate([sig7, sig8]) sig_final2 = Signature.aggregate([sig_final, sig_R2]) quotient2 = sig_final2.divide_by([sig_R2]) assert (quotient2.verify()) assert (quotient2.serialize() == bytes.fromhex( "06af6930bd06838f2e4b00b62911fb290245cce503ccf5bfc2901459897731dd08fc4c56dbde75a11677ccfbfa61ab8b14735fddc66a02b7aeebb54ab9a41488f89f641d83d4515c4dd20dfcf28cbbccb1472c327f0780be3a90c005c58a47d3" ))
def t_group_sign_verify(): msg = "NSAWatches" bmsg = formatting.binary_string([msg]) privates = [utils.private_key_gen() for i in range(5)] publics = [ PrivateKey.from_bytes(i).get_public_key().serialize() for i in privates ] sigs = [PrivateKey.from_bytes(i).sign(bmsg) for i in privates] assert utils.group_sign(sigs), "failing on group_sign()" group_sig = utils.group_sign(sigs) assert utils.aggregate_pub_keys(publics), "failing on aggregate_pub_keys()" agg_key = utils.aggregate_pub_keys(publics) assert utils.verify_sig(bmsg, agg_key, group_sig), "aggregate sig verification fails"
def test_bip39_eip2333_test_vector(self): kc: Keychain = Keychain(testing=True) kc.delete_all_keys() mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" passphrase = "TREZOR" print("entropy to seed:", mnemonic_to_seed(mnemonic, passphrase).hex()) master_sk = kc.add_private_key(mnemonic, passphrase) tv_master_int = 5399117110774477986698372024995405256382522670366369834617409486544348441851 tv_child_int = 11812940737387919040225825939013910852517748782307378293770044673328955938106 assert master_sk == PrivateKey.from_bytes( tv_master_int.to_bytes(32, "big")) child_sk = AugSchemeMPL.derive_child_sk(master_sk, 0) assert child_sk == PrivateKey.from_bytes( tv_child_int.to_bytes(32, "big"))
def sign(self, public_key: bytes, message_hash: bytes32) -> G2Element: secret_exponent = self.get(public_key) if not secret_exponent: raise ValueError("unknown pubkey %s" % public_key.hex()) bls_private_key = PrivateKey.from_bytes( secret_exponent.to_bytes(32, "big")) return AugSchemeMPL.sign(bls_private_key, message_hash)
def createKey(): seed = [] for i in range(0, 32): seed.append(SystemRandom().randrange(0, 254)) seed = bytes(seed) private_key = PrivateKey.from_seed(seed) return private_key
def test_stream(self): for _ in range(1, 64): p = PrivateKey.from_bytes(_.to_bytes(32, "big")).get_g1() blob = bytes(p) p1 = G1Element.from_bytes(blob) self.assertEqual(len(blob), 48) self.assertEqual(p, p1)
def _add_plot( self, str_path: str, plot_sk: PrivateKey, pool_pk: Optional[PublicKey] ) -> bool: plot_config = load_config(self.root_path, "plots.yaml") if pool_pk is None: for pool_pk_cand in self.pool_pubkeys: pr = DiskProver(str_path) if ( ProofOfSpace.calculate_plot_seed( pool_pk_cand, plot_sk.get_public_key() ) == pr.get_id() ): pool_pk = pool_pk_cand break if pool_pk is None: return False plot_config["plots"][str_path] = { "sk": bytes(plot_sk).hex(), "pool_pk": bytes(pool_pk).hex(), } save_config(self.root_path, "plots.yaml", plot_config) self._refresh_plots() return True
def aggsig(): seed = bytes([ 0, 50, 6, 244, 24, 199, 1, 25, 52, 88, 192, 19, 18, 12, 89, 6, 220, 18, 102, 58, 209, 82, 12, 62, 89, 110, 182, 9, 44, 20, 254, 22 ]) num = 3 #number of data packets that needs to be transferred together sk = [0] * num pk = [0] * num sig = [0] * num msg = [0] * num m = [] for j in range(num): m.append(random.randint(1, 999)) for x in range(num): seed = bytes([x + 1]) + seed[1:] sk[x] = PrivateKey.from_seed(seed) pk[x] = sk[x].get_public_key() msg[x] = bytes(m[x]) dt1 = timeit.default_timer() for x in range(num): sig[x] = sk[x].sign(msg[x]) for i in range(0, num - 1, 2): # Aggregate signatures together agg_sig_l = Signature.aggregate([sig[i], sig[i + 1]]) # Arbitrary trees of aggregates agg_sig_final = Signature.aggregate([agg_sig_l, sig[i + 2]]) sig[i + 2] = agg_sig_final dt2 = timeit.default_timer() print("Signature Generation:", (dt2 - dt1) * 1000, "ms") return agg_sig_final, msg
def additional_python_methods(): private_key = PrivateKey.from_seed(b'123') s1 = private_key.sign(b'message') s2 = private_key.sign_prepend(b'message') assert s1.get_insecure_sig().verify([Util.hash256(b'message')], [private_key.get_public_key()]) assert s2.get_insecure_sig().verify([ Util.hash256(private_key.get_public_key().serialize() + Util.hash256(b'message')) ], [private_key.get_public_key()]) s1_b = Signature.from_insecure_sig(s1.get_insecure_sig()) s2_b = PrependSignature.from_insecure_sig(s2.get_insecure_sig()) assert s1 == s1_b and s2 == s2_b s3 = private_key.sign_insecure_prehashed(Util.hash256(b'456')) assert s3.verify([Util.hash256(b'456')], [private_key.get_public_key()]) esk = ExtendedPrivateKey.from_seed(b'789') epk = esk.get_public_key() s3 = private_key.sign(b'message3') s4 = private_key.sign_insecure(b'message3') assert bytes(private_key) == private_key.serialize() assert deepcopy(private_key) == private_key assert deepcopy(s1) == s1 assert deepcopy(s2) == s2 assert deepcopy(s3) == s3 assert deepcopy(s4) == s4 assert deepcopy( private_key.get_public_key()) == private_key.get_public_key() assert deepcopy(esk) == esk assert deepcopy(epk) == epk assert deepcopy(esk.get_chain_code()) == esk.get_chain_code()
async def request_header_signature( self, request: harvester_protocol.RequestHeaderSignature ): """ The farmer requests a signature on the header hash, for one of the proofs that we found. A signature is created on the header hash using the plot private key. """ if request.quality_string not in self.challenge_hashes: return _, filename, _ = self.challenge_hashes[request.quality_string] plot_sk = PrivateKey.from_bytes( bytes.fromhex(self.plot_config["plots"][filename]["sk"]) ) header_hash_signature: PrependSignature = plot_sk.sign_prepend( request.header_hash ) assert header_hash_signature.verify( [Util.hash256(request.header_hash)], [plot_sk.get_public_key()] ) response: harvester_protocol.RespondHeaderSignature = harvester_protocol.RespondHeaderSignature( request.quality_string, header_hash_signature, ) yield OutboundMessage( NodeType.FARMER, Message("respond_header_signature", response), Delivery.RESPOND, )
async def proof_of_space_finalized( self, proof_of_space_finalized: farmer_protocol.ProofOfSpaceFinalized): """ Full node notifies farmer that a proof of space has been completed. It gets added to the challenges list at that weight, and weight is updated if necessary """ get_proofs: bool = False if (proof_of_space_finalized.weight >= self.current_weight and proof_of_space_finalized.challenge_hash not in self.seen_challenges): # Only get proofs for new challenges, at a current or new weight get_proofs = True if proof_of_space_finalized.weight > self.current_weight: self.current_weight = proof_of_space_finalized.weight # TODO: ask the pool for this information coinbase: CoinbaseInfo = CoinbaseInfo( uint32(proof_of_space_finalized.height + 1), calculate_block_reward(proof_of_space_finalized.height), bytes.fromhex(self.key_config["pool_target"]), ) pool_sks: List[PrivateKey] = [ PrivateKey.from_bytes(bytes.fromhex(ce)) for ce in self.key_config["pool_sks"] ] coinbase_signature: PrependSignature = pool_sks[0].sign_prepend( bytes(coinbase)) self.coinbase_rewards[uint32(proof_of_space_finalized.height + 1)] = ( coinbase, coinbase_signature, ) log.info(f"\tCurrent weight set to {self.current_weight}") self.seen_challenges.add(proof_of_space_finalized.challenge_hash) if proof_of_space_finalized.weight not in self.challenges: self.challenges[proof_of_space_finalized.weight] = [ proof_of_space_finalized ] else: self.challenges[proof_of_space_finalized.weight].append( proof_of_space_finalized) self.challenge_to_weight[ proof_of_space_finalized. challenge_hash] = proof_of_space_finalized.weight self.challenge_to_height[ proof_of_space_finalized. challenge_hash] = proof_of_space_finalized.height if get_proofs: message = harvester_protocol.NewChallenge( proof_of_space_finalized.challenge_hash) yield OutboundMessage( NodeType.HARVESTER, Message("new_challenge", message), Delivery.BROADCAST, )
async def test_delegated_tail(self, setup_sim): sim, sim_client = setup_sim try: standard_acs = Program.to(1) standard_acs_ph: bytes32 = standard_acs.get_tree_hash() await sim.farm_block(standard_acs_ph) starting_coin: Coin = (await sim_client.get_coin_records_by_puzzle_hash(standard_acs_ph))[0].coin sk = PrivateKey.from_bytes(secret_exponent_for_index(1).to_bytes(32, "big")) tail: Program = DelegatedLimitations.construct([Program.to(sk.get_g1())]) cat_puzzle: Program = construct_cat_puzzle(CAT_MOD, tail.get_tree_hash(), acs) cat_ph: bytes32 = cat_puzzle.get_tree_hash() await sim_client.push_tx( SpendBundle( [CoinSpend(starting_coin, standard_acs, Program.to([[51, cat_ph, starting_coin.amount]]))], G2Element(), ) ) await sim.farm_block() # We're signing a different tail to use here name_as_program = Program.to(starting_coin.name()) new_tail: Program = GenesisById.construct([name_as_program]) checker_solution: Program = DelegatedLimitations.solve( [name_as_program], { "signed_program": { "identifier": "genesis_by_id", "args": [str(name_as_program)], }, "program_arguments": {}, }, ) signature: G2Element = AugSchemeMPL.sign(sk, new_tail.get_tree_hash()) await self.do_spend( sim, sim_client, tail, [(await sim_client.get_coin_records_by_puzzle_hash(cat_ph, include_spent_coins=False))[0].coin], [NO_LINEAGE_PROOF], [ Program.to( [ [51, acs.get_tree_hash(), starting_coin.amount], [51, 0, -113, tail, checker_solution], ] ) ], (MempoolInclusionStatus.SUCCESS, None), signatures=[signature], limitations_solutions=[checker_solution], cost_str="Delegated Genesis", ) finally: await sim.close()
def test_vectors(): sk1 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5])) pk1 = sk1.get_public_key() sig1 = sk1.sign(bytes([7, 8, 9])) sk2 = PrivateKey.from_seed(bytes([1, 2, 3, 4, 5, 6])) pk2 = sk2.get_public_key() sig2 = sk2.sign(bytes([7, 8, 9])) assert (sk1.serialize() == bytes.fromhex( "022fb42c08c12de3a6af053880199806532e79515f94e83461612101f9412f9e")) assert (pk1.get_fingerprint() == 0x26d53247) assert (pk2.get_fingerprint() == 0x289bb56e) assert (sig1.serialize() == bytes.fromhex( "93eb2e1cb5efcfb31f2c08b235e8203a67265bc6a13d9f0ab77727293b74a357ff0459ac210dc851fcb8a60cb7d393a419915cfcf83908ddbeac32039aaa3e8fea82efcb3ba4f740f20c76df5e97109b57370ae32d9b70d256a98942e5806065" )) assert (sig2.serialize() == bytes.fromhex( "975b5daa64b915be19b5ac6d47bc1c2fc832d2fb8ca3e95c4805d8216f95cf2bdbb36cc23645f52040e381550727db420b523b57d494959e0e8c0c6060c46cf173872897f14d43b2ac2aec52fc7b46c02c5699ff7a10beba24d3ced4e89c821e" )) agg_sig = Signature.aggregate([sig1, sig2]) agg_pk = PublicKey.aggregate([pk1, pk2]) agg_sk = PrivateKey.aggregate([sk1, sk2], [pk1, pk2]) assert (agg_sig.serialize() == bytes.fromhex( "0a638495c1403b25be391ed44c0ab013390026b5892c796a85ede46310ff7d0e0671f86ebe0e8f56bee80f28eb6d999c0a418c5fc52debac8fc338784cd32b76338d629dc2b4045a5833a357809795ef55ee3e9bee532edfc1d9c443bf5bc658" )) assert (agg_sk.sign(bytes([7, 8, 9])).serialize() == agg_sig.serialize()) assert (sig1.verify()) assert (agg_sig.verify()) agg_sig.set_aggregation_info( AggregationInfo.from_msg(agg_pk, bytes([7, 8, 9]))) assert (agg_sig.verify()) sig1.set_aggregation_info(sig2.get_aggregation_info()) assert (not sig1.verify()) sig3 = sk1.sign(bytes([1, 2, 3])) sig4 = sk1.sign(bytes([1, 2, 3, 4])) sig5 = sk2.sign(bytes([1, 2])) agg_sig2 = Signature.aggregate([sig3, sig4, sig5]) assert (agg_sig2.verify()) assert (agg_sig2.serialize() == bytes.fromhex( "8b11daf73cd05f2fe27809b74a7b4c65b1bb79cc1066bdf839d96b97e073c1a635d2ec048e0801b4a208118fdbbb63a516bab8755cc8d850862eeaa099540cd83621ff9db97b4ada857ef54c50715486217bd2ecb4517e05ab49380c041e159b" ))
def puzzHash(pk): child_sk: PrivateKey = PrivateKey.from_bytes(bytes.fromhex(pk)) child_public_key = child_sk.get_g1() puzzle = puzzle_for_pk(child_public_key) puzzle_hash = puzzle.get_tree_hash() # xch address = encode_puzzle_hash(puzzle_hash, "txch") return address
def parse_plot_info(memo: bytes) -> Tuple[G1Element, G1Element, PrivateKey]: # Parses the plot info bytes into keys assert len(memo) == (48 + 48 + 32) return ( G1Element.from_bytes(memo[:48]), G1Element.from_bytes(memo[48:96]), PrivateKey.from_bytes(memo[96:]), )
def recovery_string_to_dict(recovery_string): recovery_dict = cbor.loads(bytes.fromhex(recovery_string)) recovery_dict['root_public_key'] = ExtendedPublicKey.from_bytes( recovery_dict['root_public_key']) recovery_dict['secret_key'] = PrivateKey.from_bytes( recovery_dict['secret_key']) recovery_dict['stake_factor'] = Decimal(recovery_dict['stake_factor']) return recovery_dict
async def add_plot(self, request: Dict) -> Dict: filename = request["filename"] if "pool_pk" in request: pool_pk = PublicKey.from_bytes(bytes.fromhex(request["pool_pk"])) else: pool_pk = None plot_sk = PrivateKey.from_bytes(bytes.fromhex(request["plot_sk"])) success = self.service._add_plot(filename, plot_sk, pool_pk) return {"success": success}
def parse_plot_info(memo: bytes) -> Tuple[Union[G1Element, bytes32], G1Element, PrivateKey]: # Parses the plot info bytes into keys if len(memo) == (48 + 48 + 32): # This is a public key memo return ( G1Element.from_bytes(memo[:48]), G1Element.from_bytes(memo[48:96]), PrivateKey.from_bytes(memo[96:]), ) elif len(memo) == (32 + 48 + 32): # This is a pool_contract_puzzle_hash memo return ( bytes32(memo[:32]), G1Element.from_bytes(memo[32:80]), PrivateKey.from_bytes(memo[80:]), ) else: raise ValueError(f"Invalid number of bytes {len(memo)}")
def generate(args, parser): root_path = args.root_path keys_yaml = "keys.yaml" key_config_filename = config_path_for_filename(root_path, keys_yaml) if args.keys != ["keys"]: parser.print_help() print("\nTry `chia generate keys`") return 1 if key_config_filename.exists(): # If the file exists, warn the user yn = input( f"The keys file {key_config_filename} already exists. Are you sure" f" you want to override the keys? Plots might become invalid. (y/n): " ) if not (yn.lower() == "y" or yn.lower() == "yes"): return 1 else: # Create the file if if doesn't exist mkdir(key_config_filename.parent) open(key_config_filename, "a").close() key_config = load_config(root_path, keys_yaml) if key_config is None: key_config = {} wallet_target = None if args.wallet: wallet_sk = ExtendedPrivateKey.from_seed(token_bytes(32)) wallet_target = create_puzzlehash_for_pk( BLSPublicKey(bytes(wallet_sk.public_child(0).get_public_key())) ) key_config["wallet_sk"] = bytes(wallet_sk).hex() key_config["wallet_target"] = wallet_target.hex() save_config(root_path, keys_yaml, key_config) if args.harvester: # Replaces the harvester's sk seed. Used to generate plot private keys, which are # used to sign farmed blocks. key_config["sk_seed"] = token_bytes(32).hex() save_config(root_path, keys_yaml, key_config) if args.pool: # Replaces the pools keys and targes. Only useful if running a pool, or doing # solo farming. The pool target allows spending of the coinbase. pool_sks = [PrivateKey.from_seed(token_bytes(32)) for _ in range(2)] if wallet_target is None: pool_target = create_puzzlehash_for_pk( BLSPublicKey(bytes(pool_sks[0].get_public_key())) ) else: pool_target = wallet_target key_config["pool_sks"] = [bytes(pool_sk).hex() for pool_sk in pool_sks] key_config["pool_target"] = pool_target.hex() save_config(root_path, keys_yaml, key_config) if args.pooltarget: # Compute a new pool target and save it to the config assert "wallet_target" in key_config key_config["pool_target"] = key_config["wallet_target"] save_config(root_path, keys_yaml, key_config)
def test2(): seed = bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) seed2 = bytes([1, 20, 102, 229, 1, 157]) sk = PrivateKey.from_seed(seed) sk_cp = PrivateKey.from_seed(seed) sk2 = PrivateKey.from_seed(seed2) pk = sk.get_public_key() pk2 = sk2.get_public_key() assert (sk == sk_cp) assert (sk != sk2) assert (pk.get_fingerprint() == 0xddad59bb) sk2_ser = sk2.serialize() pk2_ser = pk2.serialize() pk2_copy = PublicKey.from_bytes(pk2_ser) assert (pk2 == pk2_copy) assert (pk != pk2) assert (len(pk2_ser) == 48) assert (len(sk2_ser) == 32) message = bytes("this is the message", "utf-8") sig = sk.sign(message) sig_ser = sig.serialize() sig_cp = Signature.from_bytes(sig_ser) a1 = AggregationInfo.from_msg(pk, message) sig_cp.set_aggregation_info(a1) a2 = sig_cp.get_aggregation_info() assert (a1 == a2) sig2 = sk2.sign(message) assert (len(sig_ser) == 96) assert (sig != sig2) assert (sig == sig_cp) sig_agg = Signature.aggregate([sig, sig2]) result = sig_cp.verify() result2 = sig2.verify() result3 = sig_agg.verify() assert (result) assert (result2) assert (result3) sk2 = sk
def main(): """ Script for checking all plots in the plots.yaml file. Specify a number of challenge to test for each plot. """ parser = argparse.ArgumentParser(description="Chia plot checking script.") parser.add_argument("-n", "--num", help="Number of challenges", type=int, default=1000) args = parser.parse_args() v = Verifier() if os.path.isfile(plot_config_filename): plot_config = safe_load(open(plot_config_filename, "r")) for plot_filename, plot_info in plot_config["plots"].items(): plot_seed: bytes32 = ProofOfSpace.calculate_plot_seed( PublicKey.from_bytes(bytes.fromhex(plot_info["pool_pk"])), PrivateKey.from_bytes(bytes.fromhex( plot_info["sk"])).get_public_key(), ) if not os.path.isfile(plot_filename): # Tries relative path full_path: str = os.path.join(plot_root, plot_filename) if not os.path.isfile(full_path): # Tries absolute path full_path: str = plot_filename if not os.path.isfile(full_path): print(f"Plot file {full_path} not found.") continue pr = DiskProver(full_path) else: pr = DiskProver(plot_filename) total_proofs = 0 try: for i in range(args.num): challenge = sha256(i.to_bytes(32, "big")).digest() for index, quality in enumerate( pr.get_qualities_for_challenge(challenge)): proof = pr.get_full_proof(challenge, index) total_proofs += 1 ver_quality = v.validate_proof(plot_seed, pr.get_size(), challenge, proof) assert quality == ver_quality except BaseException as e: print( f"{type(e)}: {e} error in proving/verifying for plot {plot_filename}" ) print( f"{plot_filename}: Proofs {total_proofs} / {args.num}, {round(total_proofs/float(args.num), 4)}" ) else: print(f"Not plot file found at {plot_config_filename}")
def test_schemes(): # fmt: off seed = bytes([ 0, 50, 6, 244, 24, 199, 1, 25, 52, 88, 192, 19, 18, 12, 89, 6, 220, 18, 102, 58, 209, 82, 12, 62, 89, 110, 182, 9, 44, 20, 254, 22 ]) # fmt: on msg = bytes([100, 2, 254, 88, 90, 45, 23]) msg2 = bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) sk = BasicSchemeMPL.key_gen(seed) pk = sk.get_g1() assert sk == PrivateKey.from_bytes(bytes(sk)) assert pk == G1Element.from_bytes(bytes(pk)) for Scheme in (BasicSchemeMPL, AugSchemeMPL, PopSchemeMPL): sig = Scheme.sign(sk, msg) assert sig == G2Element.from_bytes(bytes(sig)) assert Scheme.verify(pk, msg, sig) seed = bytes([1]) + seed[1:] sk1 = BasicSchemeMPL.key_gen(seed) pk1 = sk1.get_g1() seed = bytes([2]) + seed[1:] sk2 = BasicSchemeMPL.key_gen(seed) pk2 = sk2.get_g1() for Scheme in (BasicSchemeMPL, AugSchemeMPL, PopSchemeMPL): # Aggregate same message agg_pk = pk1 + pk2 if Scheme is AugSchemeMPL: sig1 = Scheme.sign(sk1, msg, agg_pk) sig2 = Scheme.sign(sk2, msg, agg_pk) else: sig1 = Scheme.sign(sk1, msg) sig2 = Scheme.sign(sk2, msg) agg_sig = Scheme.aggregate([sig1, sig2]) assert Scheme.verify(agg_pk, msg, agg_sig) # Aggregate different message sig1 = Scheme.sign(sk1, msg) sig2 = Scheme.sign(sk2, msg2) agg_sig = Scheme.aggregate([sig1, sig2]) assert Scheme.aggregate_verify([pk1, pk2], [msg, msg2], agg_sig) # HD keys child = Scheme.derive_child_sk(sk1, 123) childU = Scheme.derive_child_sk_unhardened(sk1, 123) childUPk = Scheme.derive_child_pk_unhardened(pk1, 123) sig_child = Scheme.sign(child, msg) assert Scheme.verify(child.get_g1(), msg, sig_child) sigU_child = Scheme.sign(childU, msg) assert Scheme.verify(childUPk, msg, sigU_child)
async def on_connect(): # Sends a handshake to the harvester pool_sks: List[PrivateKey] = [ PrivateKey.from_bytes(bytes.fromhex(ce)) for ce in key_config["pool_sks"] ] msg = HarvesterHandshake([sk.get_public_key() for sk in pool_sks]) yield OutboundMessage(NodeType.HARVESTER, Message("harvester_handshake", msg), Delivery.BROADCAST)