Java PrivateKey类代码示例

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
/**
 * Reconstruct a secret from a collection of shares. Provided they are suffcient.
 *
 * @param shares an array of secret shares
 * @return secret if successfully recreated. The algorithm can not check for success if the shares ver not created with verbose serialization.
 * @throws HyperLedgerException
 */
public static PrivateKey reconstruct(String[] shares) throws HyperLedgerException {
    SecretShare ss[] = new SecretShare[shares.length];

    boolean comp = true;
    for (int i = 0; i < shares.length; ++i) {
        byte[] raw = ByteUtils.fromBase58WithChecksum(shares[i]);
        byte[] prefix = Arrays.copyOfRange(raw, 0, 2);
        boolean verbose = Arrays.areEqual(prefix, compressed) || !Arrays.areEqual(prefix, legacy);
        if (!verbose && !Arrays.areEqual(prefix, compressedShort) && !Arrays.areEqual(prefix, legacyShort)) {
            throw new HyperLedgerException("Not a key share");
        }
        ss[i] = new SecretShare();
        ss[i].shareNumber = raw[2] & 0xff;
        ss[i].share = new BigInteger(1, Arrays.copyOfRange(raw, verbose ? 6 : 3, 40));
        comp = raw[1] == compressed[1];
    }
    return new PrivateKey(ss256.reconstruct(ss), comp);
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void test() throws HyperLedgerException {

    byte[] offset = new byte[32];
    for (int j = 0; j < 10; ++j) {
        PrivateKey key = PrivateKey.createNew();
        for (int i = 0; i < 10; ++i) {
            random.nextBytes(offset);
            BigInteger o = new BigInteger(offset);
            PrivateKey ok = key.offsetKey(o);
            PublicKey pk = key.getPublic().offsetKey(o);
            assertEquals(ok.getPublic(), pk);
            BigInteger no = o.negate();
            assertEquals(key, ok.offsetKey(no));
        }
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void testGenerator() throws HyperLedgerException {
    MasterPrivateKey ekprivate = MasterPrivateKey.createNew();
    MasterPublicKey ekpublic = ekprivate.getMasterPublic();

    for (int i = 0; i < 20; ++i) {
        PrivateKey fullControl = ekprivate.getKey(i);
        PublicKey readOnly = ekpublic.getKey(i);

        assertEquals(fullControl.getPublic(), readOnly);
        assertTrue(fullControl.getAddress().equals(readOnly.getAddress()));

        byte[] toSign = new byte[100];
        random.nextBytes(toSign);
        byte[] signature = fullControl.sign(toSign);

        assertTrue(readOnly.verify(toSign, signature));
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void testJSON() throws HyperLedgerException, IOException, JSONException {
    JSONArray tests = readArray(TESTS);
    for (int i = 0; i < tests.length(); ++i) {
        JSONObject test = tests.getJSONObject(i);
        if (test.getString("type").equals("WIF")) {
            PrivateKey key = PrivateKey.parseWIF(test.getString("key"));
            int m = test.getInt("M");
            boolean verbose = test.getBoolean("verbose");
            JSONArray shares = test.getJSONArray("shares");
            for (int j = 0; j < shares.length(); ++j) {
                assertTrue(shares.getString(j).equals(ShamirsSecretShares.getShare(key, j, m, verbose)));
            }
        }
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Override
public void setup() throws Exception {
    PrivateKey key = PrivateKey.parseWIF("Kxj5wXRXPxVZScsHkK6Dwo2k7enphcW9wWidvZ93wTALHDXjDo2U");
    KeyListChain keyChain = new KeyListChain(key);
    BaseAccount account = new BaseAccount(keyChain);
    api.mine(keyChain.getNextReceiverAddress());
    BID topBlockId = api.getBlockIds(null, 1).idList.get(0);
    APIBlock topBlock = api.getBlock(topBlockId);
    account.sync(api);

    Transaction tx = topBlock.getTransaction(0);

    txs = new ArrayList<>(getRounds());
    for (int j = 0; j < getRounds(); j++) {
        System.out.println("Preparing round " + j);
        ArrayList<Transaction> txsForOneRound = new ArrayList<>(getCount());
        txs.add(txsForOneRound);
        for (int i = 0; i < getCount(); i++) {

            TransactionFactory tf = new BaseTransactionFactory(account);
            tx = tf.propose(key.getAddress(), 5000000000L - BaseTransactionFactory.MINIMUM_FEE).sign(keyChain);
            txsForOneRound.add(tx);
        }
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
public BlockSignatureConfig(boolean enabled, String minerPrivateKeyWIF, int requiredSignatureCount, List<String> publicKeyStrings) throws HyperLedgerException {
    this.enabled = enabled;
    if (enabled) {
        publicKeys = new ArrayList<>(publicKeyStrings.size());
        minerPrivateKey = PrivateKey.parseWIF(minerPrivateKeyWIF);
        PublicKey minerPublicKey = minerPrivateKey.getPublic();
        this.requiredSignatureCount = requiredSignatureCount;
        int counter = 0;
        for (String s : publicKeyStrings) {
            PublicKey publicKey = new PublicKey(ByteUtils.fromHex(s), true);
            publicKeys.add(publicKey);
            if (minerPublicKey.equals(publicKey)) {
                privateKeyIndex = counter;
            }
            counter++;
        }
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void wifTest() throws IOException, JSONException, HyperLedgerException {
    JSONArray testData = readObjectArray(WIF);
    for (int i = 0; i < testData.length(); ++i) {
        JSONArray test = testData.getJSONArray(i);
        PrivateKey kp = PrivateKey.parseWIF(test.getString(1));
        assertTrue(test.getString(0).equals(kp.getAddress().toString()));
        String serialized = PrivateKey.serializeWIF(kp);
        assertTrue(test.getString(1).equals(serialized));
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
@Ignore
public void rfc6979() throws IOException, JSONException, HyperLedgerException {
    JSONArray tests = readArray(TESTS);
    for (int i = 0; i < tests.length(); ++i) {
        JSONObject test = tests.getJSONObject(i);
        PrivateKey key = PrivateKey.parseWIF(test.getString("key"));
        byte[] message = test.getString("message").getBytes();
        byte[] expectedSignature = ByteUtils.fromHex(test.getString("expectedSignature"));
        byte[] signature = key.sign(message);
        assertTrue(Arrays.equals(expectedSignature, signature));
    }
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void testECDSASpeed() throws HyperLedgerException {
    PrivateKey key = PrivateKey.createNew(true);
    byte[] data = new byte[32];
    random.nextBytes(data);
    byte[] signature = key.sign(data);
    long cpu = -mxb.getCurrentThreadUserTime();
    for (int i = 0; i < 100; ++i) {
        assertTrue(key.getPublic().verify(data, signature));
    }
    cpu += mxb.getCurrentThreadUserTime();
    double speed = 100.0 / (cpu / 10.0e9);
    System.out.println("ECDSA validation speed : " + speed + " signatures/second");
    assertTrue(speed > 100.0);
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void testAddressSerialization() throws IOException, ClassNotFoundException {
    Address address = PrivateKey.createNew(true).getAddress();

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream out = new ObjectOutputStream(baos);
    out.writeObject(address);
    out.flush();

    byte[] bytes = baos.toByteArray();
    Address address2 = (Address) new ObjectInputStream(new ByteArrayInputStream(bytes)).readObject();

    assertEquals(address, address2);
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
public HyperLedgerRule(BCSAPI bcsapi, Address minerAddress, BitcoinBlockStore blockStore, int coinbaseMaturity) throws HyperLedgerException {
    this.bcsapi = bcsapi;
    this.blockStore = blockStore;
    this.coinbaseMaturity = coinbaseMaturity;
    this.minerAddress = minerAddress;
    // the below private key is the origin of the miner address in hte test-config.json, do not change them
    PrivateKey privateKey = PrivateKey.parseWIF("Kxj5wXRXPxVZScsHkK6Dwo2k7enphcW9wWidvZ93wTALHDXjDo2U");
    keyChain = new KeyListChain(privateKey);
    minerAccount = new BaseAccount(keyChain);
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
public Transaction build() {
    for (PrivateKey key : endorserKeys) {
        Endorser endorser = Endorser.create(Hash.of(outputs.get(0)).toByteArray(), key);
        endorsers.add(endorser);
    }
    return new Transaction(inputs, outputs, endorsers);
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
public static Transaction randomTx() {
    return new TransactionBuilder()
            .input(new TID(randomBytes(32)))
            .output(randomBytes(100))
            .endorse(PrivateKey.createNew(crypto))
            .build();
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void signatureValidationSucceeds() {
    PrivateKey key = PrivateKey.createNew(crypto);

    Transaction t = new TransactionBuilder()
            .output(randomBytes(100))
            .endorse(key)
            .build();

    assertTrue(t.verify(t.getEndorsers().get(0), key.getPublic()));
}
 

import org.hyperledger.common.PrivateKey; //导入依赖的package包/类
@Test
public void signatureValidationFails() {
    PrivateKey key1 = PrivateKey.createNew(crypto);
    PrivateKey key2 = PrivateKey.createNew(crypto);

    Transaction t = new TransactionBuilder()
            .output(randomBytes(100))
            .endorse(key1)
            .build();

    assertFalse(t.verify(t.getEndorsers().get(0), key2.getPublic()));
}