Example usage for org.bouncycastle.crypto.ec ECPair ECPair

List of usage examples for org.bouncycastle.crypto.ec ECPair ECPair

Introduction

In this page you can find the example usage for org.bouncycastle.crypto.ec ECPair ECPair.

Prototype

public ECPair(ECPoint x, ECPoint y) 

Source Link

Usage

From source file:org.cryptoworkshop.ximix.client.verify.ECDecryptionChallengeVerifier.java

License:Apache License

private ECPoint[] reassemblePoints(ECPoint[][] partialDecrypts, ECPair[] encMessage, BigInteger[] weights,
        int baseIndex, BigInteger baseWeight) {
    ECPoint[] weightedDecryptions = new ECPoint[partialDecrypts[0].length];
    ECPoint[] fulls = new ECPoint[partialDecrypts[0].length];

    ECPair[] partials = new ECPair[partialDecrypts[baseIndex].length];

    for (int i = 0; i != partials.length; i++) {
        partials[i] = new ECPair(partialDecrypts[baseIndex][i], encMessage[i].getY());
    }/*from  ww w  .j  a  v a 2s  .  c  om*/

    for (int i = 0; i != weightedDecryptions.length; i++) {
        weightedDecryptions[i] = partials[i].getX().multiply(baseWeight);
    }

    for (int wIndex = baseIndex + 1; wIndex < weights.length; wIndex++) {
        if (weights[wIndex] != null) {
            for (int i = 0; i != weightedDecryptions.length; i++) {
                weightedDecryptions[i] = weightedDecryptions[i]
                        .add(partialDecrypts[wIndex][i].multiply(weights[wIndex]));
            }
        }
    }

    for (int i = 0; i != weightedDecryptions.length; i++) {
        fulls[i] = partials[i].getY().add(weightedDecryptions[i].negate());
    }

    return fulls;
}

From source file:org.cryptoworkshop.ximix.common.asn1.board.Pair.java

License:Apache License

public static Pair getInstance(ECCurve curve, Object o) {
    if (o instanceof Pair) {
        return (Pair) o;
    }//from  ww  w  .j  av a 2  s .  c  o m
    if (o != null) {
        ASN1Sequence s = ASN1Sequence.getInstance(o);

        byte[] encX = ASN1OctetString.getInstance(s.getObjectAt(0)).getOctets();
        byte[] encY = ASN1OctetString.getInstance(s.getObjectAt(1)).getOctets();

        return new Pair(new ECPair(curve.decodePoint(encX), curve.decodePoint(encY)));
    }

    return null;
}

From source file:org.cryptoworkshop.ximix.node.crypto.service.NodeDecryptionService.java

License:Apache License

public MessageReply handle(Message message) {
    switch (((CommandMessage) message).getType()) {
    case PARTIAL_DECRYPT:
        DecryptDataMessage decMessage = DecryptDataMessage.getInstance(message.getPayload());
        List<byte[]> messages = decMessage.getMessages();
        PostedMessageDataBlock.Builder partialDecryptsBuilder = new PostedMessageDataBlock.Builder(
                messages.size());/*from w  ww  . j a  va 2 s  . c  o  m*/

        PrivateKeyOperator operator = nodeContext.getPrivateKeyOperator(decMessage.getKeyID());

        if (!(operator instanceof ECPrivateKeyOperator)) {
            return new MessageReply(MessageReply.Type.ERROR, new DERUTF8String("Inappropriate key type"));
        }

        ECPrivateKeyOperator ecOperator = (ECPrivateKeyOperator) operator;

        ECDomainParameters domainParameters = ecOperator.getDomainParameters();

        ProofGenerator pGen = new ProofGenerator(ecOperator, new SecureRandom()); // TODO: randomness

        for (int i = 0; i != messages.size(); i++) {
            PairSequence ps = PairSequence.getInstance(domainParameters.getCurve(), messages.get(i));
            ECPair[] pairs = ps.getECPairs();
            ECDecryptionProof[] proofs = new ECDecryptionProof[pairs.length];

            for (int j = 0; j != pairs.length; j++) {
                ECPoint c = pairs[j].getX();
                pairs[j] = new ECPair(ecOperator.transform(pairs[j].getX()), pairs[j].getY());

                proofs[j] = pGen.computeProof(c, pairs[j]);
            }

            try {
                partialDecryptsBuilder.add(new PairSequenceWithProofs(pairs, proofs).getEncoded());
            } catch (IOException e) {
                nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                        "Error encoding decrypt: " + e.getMessage(), e);

                return new MessageReply(MessageReply.Type.ERROR,
                        new DERUTF8String("Error encoding decrypt: " + e.getMessage()));
            }
        }

        return new MessageReply(MessageReply.Type.OKAY,
                new ShareMessage(operator.getSequenceNo(), partialDecryptsBuilder.build()));
    default:
        nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                "Unknown command: " + message.getType());

        return new MessageReply(MessageReply.Type.ERROR,
                new DERUTF8String("Unknown command: " + message.getType()));
    }
}

From source file:org.cryptoworkshop.ximix.node.crypto.service.NodeShuffledBoardDecryptionService.java

License:Apache License

public MessageReply handle(Message message) {
    switch (((CommandMessage) message).getType()) {
    case FILE_UPLOAD:
        FileTransferMessage transMessage = FileTransferMessage.getInstance(message.getPayload());
        File destinationFile = new File(workDirectory, transMessage.getFileName());

        try {/*from w w w  .  j a  v  a2 s .  co m*/
            OutputStream fileStream = activeFiles.get(destinationFile);
            if (fileStream == null) {
                fileStream = new BufferedOutputStream(new FileOutputStream(destinationFile));

                activeFiles.put(destinationFile, fileStream);
            }

            if (transMessage.isEndOfTransfer()) {
                fileStream.close();

                activeFiles.remove(destinationFile);
            } else {
                fileStream.write(transMessage.getChunk());
            }
        } catch (IOException e) {
            return new MessageReply(MessageReply.Type.ERROR,
                    new DERUTF8String(transMessage.getFileName() + ": " + e.getMessage()));
        }
        return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(transMessage.getFileName()));
    case SETUP_PARTIAL_DECRYPT:
        final DecryptShuffledBoardMessage setupMessage = DecryptShuffledBoardMessage
                .getInstance(message.getPayload());

        SubjectPublicKeyInfo keyInfo = nodeContext.getPublicKey(setupMessage.getKeyID());
        ECPublicKeyParameters pubKey;

        try {
            if (keyInfo != null) {
                pubKey = (ECPublicKeyParameters) PublicKeyFactory.createKey(keyInfo);
            } else {
                // see if the key exists elsewhere on the MIXNET.
                FetchPublicKeyMessage fetchMessage = new FetchPublicKeyMessage(setupMessage.getKeyID());

                MessageReply reply = nodeContext.getPeerMap().values().iterator().next()
                        .sendMessage(ClientMessage.Type.FETCH_PUBLIC_KEY, fetchMessage);

                if (reply.getPayload() != null) {
                    pubKey = (ECPublicKeyParameters) PublicKeyFactory
                            .createKey(reply.getPayload().toASN1Primitive().getEncoded());
                } else {
                    nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                            "Unable to find public key " + setupMessage.getKeyID());

                    return new MessageReply(MessageReply.Type.ERROR,
                            new DERUTF8String("Unable to locate key " + setupMessage.getKeyID()));
                }
            }
        } catch (Exception e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    "Unable to process data for key " + setupMessage.getKeyID());

            return new MessageReply(MessageReply.Type.ERROR,
                    new DERUTF8String("Unable to process data for key " + setupMessage.getKeyID()));
        }

        // verify signatures.
        File[] files = workDirectory.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.startsWith(setupMessage.getBoardName()) && name.endsWith(".gtr");
            }
        });

        final Map<Integer, File> generalTranscripts = createTranscriptMap(signatureVerifier, files);

        int boardSize;

        try {
            boardSize = LinkIndexVerifier.getAndCheckBoardSize(files);
        } catch (TranscriptVerificationException e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    "Decrypt refused, size validation failed: " + e.getMessage(), e);

            return new MessageReply(MessageReply.Type.ERROR,
                    new DERUTF8String("Decrypt refused, size validation failed: " + e.getMessage()));
        }

        files = workDirectory.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.startsWith(setupMessage.getBoardName()) && name.endsWith(".wtr");
            }
        });

        final Map<Integer, File> witnessTranscripts = createTranscriptMap(signatureVerifier, files);

        files = workDirectory.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.startsWith(setupMessage.getBoardName()) && name.endsWith(".sc");
            }
        });

        final Map<String, byte[]> seedCommitmentMap = createSeedCommitmentMap(signatureVerifier, files);

        files = workDirectory.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                return name.startsWith(setupMessage.getBoardName()) && name.endsWith(".svw");
            }
        });

        final Map<String, byte[][]> seedAndWitnessesMap = createSeedAndWitnessMap(files);

        LinkIndexVerifier.Builder verifierBuilder = new LinkIndexVerifier.Builder(boardSize);

        try {
            verifierBuilder.setNetworkSeeds(seedCommitmentMap, seedAndWitnessesMap);

            for (Integer key : generalTranscripts.keySet()) {
                BufferedInputStream bIn = new BufferedInputStream(
                        new FileInputStream(generalTranscripts.get(key)));

                verifierBuilder.addTranscript(bIn);

                bIn.close();
            }

            LinkIndexVerifier linkIndexVerifier = verifierBuilder.build();

            // verify which links have been opened.
            for (Integer key : witnessTranscripts.keySet()) {
                BufferedInputStream bIn = new BufferedInputStream(
                        new FileInputStream(witnessTranscripts.get(key)));

                linkIndexVerifier.verify(key, setupMessage.isWithPairing(), bIn);

                bIn.close();
            }

            linkIndexVerifier = null; // free the resources

            // verify the opened commitments.
            for (Integer key : witnessTranscripts.keySet()) {
                File transcriptFile = witnessTranscripts.get(key);
                File initialTranscript = generalTranscripts.get(key);
                File nextTranscript = generalTranscripts.get(key + 1);

                InputStream witnessTranscriptStream = new BufferedInputStream(
                        new FileInputStream(transcriptFile));

                ECShuffledTranscriptVerifier verifier = new ECShuffledTranscriptVerifier(pubKey,
                        witnessTranscriptStream, initialTranscript, nextTranscript);

                verifier.verify();

                witnessTranscriptStream.close();
            }
        } catch (CommitmentVerificationException e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    "Decrypt refused, validation failed: " + e.getMessage(), e);

            return new MessageReply(MessageReply.Type.ERROR,
                    new DERUTF8String("Decrypt refused, validation failed: " + e.getMessage()));
        } catch (TranscriptVerificationException e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    "Decrypt refused, validation failed: " + e.getMessage(), e);

            return new MessageReply(MessageReply.Type.ERROR,
                    new DERUTF8String("Decrypt refused, validation failed: " + e.getMessage()));
        } catch (Exception e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    setupMessage.getBoardName() + ": " + e.getMessage(), e);

            return new MessageReply(MessageReply.Type.ERROR,
                    new DERUTF8String(setupMessage.getBoardName() + ": " + e.getMessage()));
        }

        File finalFile = generalTranscripts.get(witnessTranscripts.size());

        try {
            CMSSignedDataParser cmsParser = new CMSSignedDataParser(new BcDigestCalculatorProvider(),
                    new BufferedInputStream(new FileInputStream(finalFile)));

            activeDecrypts.put(setupMessage.getBoardName(),
                    new ASN1InputStream(cmsParser.getSignedContent().getContentStream()));

            return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(setupMessage.getBoardName()));
        } catch (Exception e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    "Unable to process data for download key " + setupMessage.getKeyID());

            return new MessageReply(MessageReply.Type.ERROR,
                    new ErrorMessage("Error opening posted message stream"));
        }
    case DOWNLOAD_PARTIAL_DECRYPTS:
        DownloadShuffledBoardMessage downMessage = DownloadShuffledBoardMessage
                .getInstance(message.getPayload());

        PostedMessageDataBlock.Builder partialDecryptsBuilder = new PostedMessageDataBlock.Builder(
                downMessage.getBlockSize());

        PrivateKeyOperator operator = nodeContext.getPrivateKeyOperator(downMessage.getKeyID());

        if (!(operator instanceof ECPrivateKeyOperator)) {
            return new MessageReply(MessageReply.Type.ERROR, new ErrorMessage("Inappropriate key type"));
        }

        ECPrivateKeyOperator ecOperator = (ECPrivateKeyOperator) operator;

        ECDomainParameters domainParameters = ecOperator.getDomainParameters();

        ASN1InputStream aIn = activeDecrypts.get(downMessage.getBoardName());

        if (aIn == null) {
            return new MessageReply(MessageReply.Type.OKAY,
                    new ShareMessage(operator.getSequenceNo(), partialDecryptsBuilder.build()));
        }

        try {
            Object o = null;
            ProofGenerator pGen = new ProofGenerator(ecOperator, new SecureRandom()); // TODO: randomness
            while (partialDecryptsBuilder.hasCapacity() && (o = aIn.readObject()) != null) {
                PostedMessage postedMessage = PostedMessage.getInstance(o);
                PairSequence ps = PairSequence.getInstance(domainParameters.getCurve(),
                        postedMessage.getMessage());
                ECPair[] pairs = ps.getECPairs();
                ECDecryptionProof[] proofs = new ECDecryptionProof[pairs.length];

                for (int j = 0; j != pairs.length; j++) {
                    ECPoint c = pairs[j].getX();
                    pairs[j] = new ECPair(ecOperator.transform(pairs[j].getX()), pairs[j].getY());
                    proofs[j] = pGen.computeProof(c, pairs[j]);
                }

                partialDecryptsBuilder.add(new PairSequenceWithProofs(pairs, proofs).getEncoded());
            }

            if (o == null) {
                activeDecrypts.remove(downMessage.getBoardName());
                aIn.close();
            }

            return new MessageReply(MessageReply.Type.OKAY,
                    new ShareMessage(operator.getSequenceNo(), partialDecryptsBuilder.build()));
        } catch (Exception e) {
            nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                    "Error parsing posted message stream: " + e.getMessage(), e);

            return new MessageReply(MessageReply.Type.ERROR,
                    new ErrorMessage("Error parsing posted message stream: " + e.getMessage()));
        }
    default:
        nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR,
                "Unknown command: " + message.getType());

        return new MessageReply(MessageReply.Type.ERROR,
                new ErrorMessage("Unknown command: " + message.getType()));
    }
}