Java ECKey类代码示例

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
private void sign() {
    flags |= SIGNATURE_FLAG;
    byte[] forSig = hash();

    ECKey.ECDSASignature signature = from.sign(forSig);

    byte v;

    if (signature.v == 27) v = 0;
    else if (signature.v == 28) v = 1;
    else throw new RuntimeException("Invalid signature: " + signature);

    this.signature =
            merge(BigIntegers.asUnsignedByteArray(32, signature.r),
                    BigIntegers.asUnsignedByteArray(32, signature.s), new byte[]{v});
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public AuthResponseMessageV4 decryptAuthResponseV4(byte[] in, ECKey myKey) {
    try {

        byte[] prefix = new byte[2];
        System.arraycopy(in, 0, prefix, 0, 2);
        short size = ByteUtil.bigEndianToShort(prefix, 0);
        byte[] ciphertext = new byte[size];
        System.arraycopy(in, 2, ciphertext, 0, size);

        byte[] plaintext = ECIESCoder.decrypt(myKey.getPrivKey(), ciphertext, prefix);

        return AuthResponseMessageV4.decode(plaintext);
    } catch (IOException | InvalidCipherTextException e) {
        throw Throwables.propagate(e);
    }
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public static NeighborsPeerMessage create(List<Node> nodes, String check, ECKey privKey) {
    byte[][] nodeRLPs = null;

    if (nodes != null) {
        nodeRLPs = new byte[nodes.size()][];
        int i = 0;
        for (Node node : nodes) {
            nodeRLPs[i] = node.getRLP();
            ++i;
        }
    }

    byte[] rlpListNodes = RLP.encodeList(nodeRLPs);
    byte[] rlpCheck = RLP.encodeElement(check.getBytes(StandardCharsets.UTF_8));

    byte[] type = new byte[]{(byte) DiscoveryMessageType.NEIGHBORS.getTypeValue()};
    byte[] data = RLP.encodeList(rlpListNodes, rlpCheck);

    NeighborsPeerMessage neighborsMessage = new NeighborsPeerMessage();
    neighborsMessage.encode(type, data, privKey);
    neighborsMessage.nodes = nodes;
    neighborsMessage.messageId = check;

    return neighborsMessage;
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public Account getAccount(RskAddress address) {
    synchronized (accessLock) {
        if (!accounts.containsKey(address)) {
            return null;
        }

        if (unlocksTimeouts.containsKey(address)) {
            long ending = unlocksTimeouts.get(address);
            long time = System.currentTimeMillis();
            if (ending < time) {
                unlocksTimeouts.remove(address);
                accounts.remove(address);
                return null;
            }
        }
        return new Account(ECKey.fromPrivate(accounts.get(address)));
    }
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
@Ignore
@Test
public void testTransactionFromNew1() throws MissingPrivateKeyException {
    Transaction txNew = new Transaction(testNonce, testGasPrice, testGasLimit, testReceiveAddress, testValue, testData);

    assertEquals("", Hex.toHexString(txNew.getNonce()));
    assertEquals(new BigInteger(1, testGasPrice), new BigInteger(1, txNew.getGasPrice()));
    assertEquals(new BigInteger(1, testGasLimit), new BigInteger(1, txNew.getGasLimit()));
    assertEquals(Hex.toHexString(testReceiveAddress), Hex.toHexString(txNew.getReceiveAddress()));
    assertEquals(new BigInteger(1, testValue), new BigInteger(1, txNew.getValue()));
    assertEquals("", Hex.toHexString(txNew.getData()));
    assertNull(txNew.getSignature());

    assertEquals(RLP_ENCODED_RAW_TX, Hex.toHexString(txNew.getEncodedRaw()));
    assertEquals(HASH_TX, Hex.toHexString(txNew.getHash()));
    assertEquals(RLP_ENCODED_UNSIGNED_TX, Hex.toHexString(txNew.getEncoded()));
    txNew.sign(ECKey.fromPrivate(Hex.decode(KEY)));
    assertEquals(RLP_ENCODED_SIGNED_TX, Hex.toHexString(txNew.getEncoded()));

    assertEquals(27, txNew.getSignature().v);
    assertEquals("eab47c1a49bf2fe5d40e01d313900e19ca485867d462fe06e139e3a536c6d4f4", Hex.toHexString(BigIntegers.asUnsignedByteArray(txNew.getSignature().r)));
    assertEquals("14a569d327dcda4b29f74f93c0e9729d2f49ad726e703f9cd90dbb0fbf6649f1", Hex.toHexString(BigIntegers.asUnsignedByteArray(txNew.getSignature().s)));
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
private String getGeneratedNodePrivateKey() {
    try {
        File file = new File(databaseDir(), "nodeId.properties");
        Properties props = new Properties();
        if (file.canRead()) {
            props.load(new FileReader(file));
        } else {
            ECKey key = new ECKey();
            props.setProperty("nodeIdPrivateKey", Hex.toHexString(key.getPrivKeyBytes()));
            props.setProperty("nodeId", Hex.toHexString(key.getNodeId()));
            file.getParentFile().mkdirs();
            props.store(new FileWriter(file), "Generated NodeID. To use your own nodeId please refer to 'peer.privateKey' config option.");
            logger.info("New nodeID generated: " + props.getProperty("nodeId"));
            logger.info("Generated nodeID and its private key stored in " + file);
        }
        return props.getProperty("nodeIdPrivateKey");
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
/**
 * Create a handshake auth message
 *
 * @param token previous token if we had a previous session
 * @param key our private key
 */
public AuthInitiateMessage createAuthInitiate(@Nullable byte[] token, ECKey key) {
    AuthInitiateMessage message = new AuthInitiateMessage();
    boolean isToken;
    if (token == null) {
        isToken = false;
        BigInteger secretScalar = remotePublicKey.multiply(key.getPrivKey()).normalize().getXCoord().toBigInteger();
        token = ByteUtil.bigIntegerToBytes(secretScalar, NONCE_SIZE);
    } else {
        isToken = true;
    }

    byte[] nonce = initiatorNonce;
    byte[] signed = xor(token, nonce);
    message.signature = ephemeralKey.sign(signed);
    message.isTokenUsed = isToken;
    message.ephemeralPublicHash = sha3(ephemeralKey.getPubKeyPoint().getEncoded(false), 1, 64);
    message.publicKey = key.getPubKeyPoint();
    message.nonce = initiatorNonce;
    return message;
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
AuthResponseMessage makeAuthInitiate(AuthInitiateMessage initiate, ECKey key) {
    initiatorNonce = initiate.nonce;
    remotePublicKey = initiate.publicKey;
    BigInteger secretScalar = remotePublicKey.multiply(key.getPrivKey()).normalize().getXCoord().toBigInteger();
    byte[] token = ByteUtil.bigIntegerToBytes(secretScalar, NONCE_SIZE);
    byte[] signed = xor(token, initiatorNonce);

    ECKey ephemeral = ECKey.recoverFromSignature(recIdFromSignatureV(initiate.signature.v),
            initiate.signature, signed, false);
    if (ephemeral == null) {
        throw new RuntimeException("failed to recover signatue from message");
    }
    remoteEphemeralKey = ephemeral.getPubKeyPoint();
    AuthResponseMessage response = new AuthResponseMessage();
    response.isTokenUsed = initiate.isTokenUsed;
    response.ephemeralPublicKey = ephemeralKey.getPubKeyPoint();
    response.nonce = responderNonce;
    return response;
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public synchronized RskAddress getSender() {
    if (sender != null) {
        return sender;
    }

    try {
        ECKey key = ECKey.signatureToKey(getRawHash(), getSignature().toBase64());
        sender = new RskAddress(key.getAddress());
    } catch (SignatureException e) {
        logger.error(e.getMessage(), e);
        panicProcessor.panic("transaction", e.getMessage());
        sender = RskAddress.nullAddress();
    }

    return sender;
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
private static Config getConfig(int index, String discoveryNode) {
    return ConfigFactory.empty()
            .withValue("peer.discovery.enabled", value(true))
            .withValue("peer.discovery.external.ip", value("127.0.0.1"))
            .withValue("peer.discovery.bind.ip", value("127.0.0.1"))
            .withValue("peer.discovery.persist", value("false"))

            .withValue("peer.listen.port", value(20000 + index))
            .withValue("peer.privateKey", value(Hex.toHexString(ECKey.fromPrivate(("" + index).getBytes()).getPrivKeyBytes())))
            .withValue("peer.networkId", value(555))
            .withValue("sync.enabled", value(true))
            .withValue("database.incompatibleDatabaseBehavior", value("RESET"))
            .withValue("genesis", value("sample-genesis.json"))
            .withValue("database.dir", value("sampleDB-" + index))
            .withValue("peer.discovery.ip.list", value(discoveryNode != null ? Arrays.asList(discoveryNode) : Arrays.asList()));
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
@Test
public void create() {
    ECKey key = new ECKey();
    String check = UUID.randomUUID().toString();
    PingPeerMessage pingPeerMessage = PingPeerMessage.create("localhost", 80, check, key);
    PongPeerMessage pongPeerMessage = PongPeerMessage.create("localhost", 80, check, key);
    InetSocketAddress address = new InetSocketAddress("localhost", 8080);

    PeerDiscoveryRequest request = PeerDiscoveryRequestBuilder.builder().messageId(check)
            .message(pingPeerMessage).address(address).expectedResponse(DiscoveryMessageType.PONG)
            .expirationPeriod(1000).attemptNumber(1).build();

    Assert.assertNotNull(request);
    Assert.assertTrue(request.validateMessageResponse(pongPeerMessage));
    Assert.assertFalse(request.validateMessageResponse(pingPeerMessage));
}
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public static FindNodeMessage create(byte[] target, ECKey privKey) {

        long expiration = 90 * 60 + System.currentTimeMillis() / 1000;

        /* RLP Encode data */
        byte[] rlpToken = RLP.encodeElement(target);

        byte[] rlpExp = longToBytesNoLeadZeroes(expiration);
        rlpExp = RLP.encodeElement(rlpExp);

        byte[] type = new byte[]{3};
        byte[] data = RLP.encodeList(rlpToken, rlpExp);

        FindNodeMessage findNode = new FindNodeMessage();
        findNode.encode(type, data, privKey);
        findNode.target = target;
        findNode.expires = expiration;

        return findNode;
    }
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public static PingMessage create(Node fromNode, Node toNode, ECKey privKey, int version) {

        long expiration = 90 * 60 + System.currentTimeMillis() / 1000;

        /* RLP Encode data */
        byte[] tmpExp = longToBytes(expiration);
        byte[] rlpExp = RLP.encodeElement(stripLeadingZeroes(tmpExp));

        byte[] type = new byte[]{1};
        byte[] rlpVer = RLP.encodeInt(version);
        byte[] rlpFromList = fromNode.getBriefRLP();
        byte[] rlpToList = toNode.getBriefRLP();
        byte[] data = RLP.encodeList(rlpVer, rlpFromList, rlpToList, rlpExp);

        PingMessage ping = new PingMessage();
        ping.encode(type, data, privKey);

        ping.expires = expiration;
        ping.toHost = toNode.getHost();
        ping.toPort = toNode.getPort();
        ping.fromHost = fromNode.getHost();
        ping.fromPort = fromNode.getPort();

        return ping;
    }
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public void execute(){

        byte[] key = Hex.decode(this.key);
        byte[] cipher = Hex.decode(this.cipher);

        ECKey ecKey = ECKey.fromPrivate(key);

        byte[] resultPayload = new byte[0];
        if (decryption_type.equals("aes_ctr"))
            resultPayload = ecKey.decryptAES(cipher);

        if (decryption_type.equals("ecies_sec1_altered"))
            try {
                resultPayload = ECIESCoder.decrypt(new BigInteger(Hex.toHexString(key), 16), cipher);
            } catch (Throwable e) {e.printStackTrace();}

        if (!Hex.toHexString(resultPayload).equals(payload)){
            String error = String.format("payload should be: %s, but got that result: %s  ",
                    payload, Hex.toHexString(resultPayload));
            logger.info(error);

            System.exit(-1);
        }
    }
 

import org.ethereum.crypto.ECKey; //导入依赖的package包/类
public boolean decrypt(Collection<ECKey> identities, Collection<Topic> knownTopics) {
        boolean ok = false;
        for (ECKey key : identities) {
            ok = decrypt(key);
            if (ok) break;
        }

        if (!ok) {
        // decrypting as broadcast
            ok = openBroadcastMessage(knownTopics);
        }

        if (ok) {
            return processSignature();
        }

        // the message might be either not-encrypted or encrypted but we have no receivers
        // now way to know so just assuming that the message is broadcast and not encrypted
//        setEncrypted(false);
        return false;
    }