Example usage for org.bouncycastle.asn1 DERSequence DERSequence

List of usage examples for org.bouncycastle.asn1 DERSequence DERSequence

  1. HOME
  2. Java
  3. org.bouncycastle
  4. org.bouncycastle.asn1.*
  5. DERSequence
  6. DERSequence

Introduction

In this page you can find the example usage for org.bouncycastle.asn1 DERSequence DERSequence.

Prototype

public DERSequence(ASN1Encodable[] elements)

Source Link

Document

Create a sequence containing an array of objects.

Usage

From source file:org.cryptoworkshop.ximix.node.crypto.key.message.ECCommittedSecretShareMessage.java

License:Apache License

@Override
public ASN1Primitive toASN1Primitive() {
    ASN1EncodableVector v = new ASN1EncodableVector();

    v.add(new ASN1Integer(index));
    v.add(new ASN1Integer(value));
    v.add(new ASN1Integer(witness));

    ASN1EncodableVector factV = new ASN1EncodableVector();
    for (int i = 0; i != commitmentFactors.length; i++) {
        factV.add(new DEROctetString(commitmentFactors[i].getEncoded()));
    }/*from   w  w w  .ja  va  2  s .  c  o m*/

    v.add(new DERSequence(factV));
    v.add(new DEROctetString(q.getEncoded()));

    ASN1EncodableVector qFactV = new ASN1EncodableVector();
    for (int i = 0; i != qCommitmentFactors.length; i++) {
        qFactV.add(new DEROctetString(qCommitmentFactors[i].getEncoded()));
    }

    v.add(new DERSequence(qFactV));

    return new DERSequence(v);
}

From source file:org.cryptoworkshop.ximix.node.mixnet.service.BoardHostingService.java

License:Apache License

private FutureTask<MessageReply> submitToHandle(Message message) {
    if (message instanceof CommandMessage) {
        switch (((CommandMessage) message).getType()) {
        case GENERATE_SEED:
            final SeedMessage seedMessage = SeedMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(seedMessage.getBoardName(), new Callable<MessageReply>() {
                @Override/*from w  ww  . jav  a  2 s  .co  m*/
                public MessageReply call() throws Exception {
                    String seedKey = seedMessage.getBoardName() + "." + seedMessage.getOperationNumber();
                    if (seedsAndWitnesses.containsKey(seedKey)) {
                        return new MessageReply(MessageReply.Type.ERROR,
                                new ErrorMessage("Duplicate seed generation request for operation "
                                        + seedMessage.getOperationNumber()));
                    }
                    // TODO: specify source of randomness
                    SecureRandom random = new SecureRandom();

                    byte[] seed = new byte[64]; // largest we can manage with SHA-512

                    random.nextBytes(seed);

                    GeneralHashCommitter sha512Committer = new GeneralHashCommitter(new SHA512Digest(), random);

                    Commitment commitment = sha512Committer.commit(seed);

                    seedsAndWitnesses.put(seedKey, new byte[][] { seed, commitment.getSecret() });

                    SeedCommitmentMessage seedCommitmentMessage = new SeedCommitmentMessage(
                            seedMessage.getBoardName(), seedMessage.getOperationNumber(),
                            commitment.getCommitment());

                    CMSSignedDataGenerator cmsGen = new CMSSignedDataGenerator();

                    KeyStore nodeCAStore = nodeContext.getNodeCAStore();
                    Certificate[] nodeCerts = nodeCAStore.getCertificateChain("nodeCA");

                    cmsGen.addSignerInfoGenerator(new JcaSimpleSignerInfoGeneratorBuilder().setProvider("BC")
                            .build("SHA256withECDSA", (PrivateKey) nodeCAStore.getKey("nodeCA", new char[0]),
                                    (X509Certificate) nodeCerts[0]));

                    for (Certificate cert : nodeCerts) {
                        cmsGen.addCertificate(new JcaX509CertificateHolder((X509Certificate) cert));
                    }

                    return new MessageReply(MessageReply.Type.OKAY, cmsGen
                            .generate(new CMSProcessableByteArray(seedCommitmentMessage.getEncoded()), true)
                            .toASN1Structure());
                }
            });
        case FETCH_SEED:
            final SeedMessage seedFetchMessage = SeedMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(seedFetchMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    String seedKey = seedFetchMessage.getBoardName() + "."
                            + seedFetchMessage.getOperationNumber();
                    byte[][] seedAndWitness = seedsAndWitnesses.get(seedKey);

                    if (seedAndWitness == null) {
                        return new MessageReply(MessageReply.Type.ERROR,
                                new ErrorMessage("Unknown seed requested for key: " + seedKey));
                    }

                    return new MessageReply(MessageReply.Type.OKAY,
                            new SeedAndWitnessMessage(seedAndWitness[0], seedAndWitness[1]));
                }
            });
        case GET_BOARD_DETAILS:
            Callable<MessageReply> replyCallable = new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    String[] boardNames = boardRegistry.getBoardNames();
                    BoardDetailMessage[] details = new BoardDetailMessage[boardNames.length];

                    int count = 0;
                    for (String boardName : boardNames) {
                        BulletinBoard board = boardRegistry.getBoard(boardName);

                        details[count++] = new BoardDetailMessage(boardName, nodeContext.getName(),
                                board.size(), board.getBackupHost());
                    }

                    return new MessageReply(MessageReply.Type.OKAY, new DERSequence(details));
                }
            };
            FutureTask<MessageReply> task = new FutureTask<>(replyCallable);

            boardExecutor.execute(task);

            return task;
        case GET_BOARD_HOST:
            final BoardMessage boardMessage = BoardMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(boardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    String boardHost = nodeContext.getBoardHost(boardMessage.getBoardName());

                    if (boardHost != null) {
                        return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(boardHost));
                    } else {
                        return new MessageReply(MessageReply.Type.OKAY, DERNull.INSTANCE);
                    }
                }
            });
        case ACTIVATE_BOARD:
            final BoardMessage activateBoardMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(activateBoardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    boardRegistry.activateBoard(activateBoardMessage.getBoardName());
                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case SUSPEND_BOARD:
            final BoardMessage suspendBoardMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(suspendBoardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    if (boardRegistry.isSuspended(suspendBoardMessage.getBoardName())) {
                        return new MessageReply(MessageReply.Type.ERROR, new BoardErrorStatusMessage(
                                suspendBoardMessage.getBoardName(), BoardErrorStatusMessage.Status.SUSPENDED));
                    }
                    boardRegistry.suspendBoard(suspendBoardMessage.getBoardName());
                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case BOARD_CREATE:
            final CreateBoardMessage createBoardMessage = CreateBoardMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(createBoardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    if (boardRegistry.hasBoard(createBoardMessage.getBoardName())) {
                        return new MessageReply(MessageReply.Type.ERROR,
                                new BoardErrorStatusMessage(createBoardMessage.getBoardName(),
                                        BoardErrorStatusMessage.Status.ALREADY_EXISTS));
                    }

                    if (createBoardMessage.getBackUpHost() != null) {
                        boardRegistry.createBoard(createBoardMessage.getBoardName(),
                                createBoardMessage.getBackUpHost());
                    } else {
                        boardRegistry.createBoard(createBoardMessage.getBoardName());
                    }

                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case BACKUP_BOARD_CREATE:
            final BoardMessage backupBoardCreateMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(backupBoardCreateMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {

                            boardRegistry.createBackupBoard(backupBoardCreateMessage.getBoardName());

                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case BOARD_DOWNLOAD_LOCK:
            final BoardMessage downloadLockBoardMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(downloadLockBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {
                            if (boardRegistry.isLocked(downloadLockBoardMessage.getBoardName())) {
                                return new MessageReply(MessageReply.Type.ERROR,
                                        new BoardErrorStatusMessage(downloadLockBoardMessage.getBoardName(),
                                                BoardErrorStatusMessage.Status.SUSPENDED));
                            }
                            boardRegistry.downloadLock(downloadLockBoardMessage.getBoardName());
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case BOARD_DOWNLOAD_UNLOCK:
            final BoardMessage downloadUnlockBoardMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(downloadUnlockBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {
                            boardRegistry.downloadUnlock(downloadUnlockBoardMessage.getBoardName());
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case BOARD_SHUFFLE_LOCK:
            final BoardMessage shuffleLockBoardMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(shuffleLockBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {
                            if (boardRegistry.isLocked(shuffleLockBoardMessage.getBoardName())) {
                                return new MessageReply(MessageReply.Type.ERROR,
                                        new BoardErrorStatusMessage(shuffleLockBoardMessage.getBoardName(),
                                                BoardErrorStatusMessage.Status.SUSPENDED));
                            }
                            boardRegistry.shuffleLock(shuffleLockBoardMessage.getBoardName());
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case BOARD_SHUFFLE_UNLOCK:
            final BoardMessage shuffleUnlockBoardMessage = BoardMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(shuffleUnlockBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {

                            boardRegistry.shuffleUnlock(shuffleUnlockBoardMessage.getBoardName());
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case FETCH_BOARD_STATUS:
            final TransitBoardMessage transitBoardMessage = TransitBoardMessage
                    .getInstance(message.getPayload());
            return boardExecutor.submitTask(transitBoardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    if (boardRegistry.isInTransit(transitBoardMessage.getOperationNumber(),
                            transitBoardMessage.getBoardName(), transitBoardMessage.getStepNumber())) {
                        return new MessageReply(MessageReply.Type.OKAY, new BoardStatusMessage(
                                transitBoardMessage.getBoardName(), BoardStatusMessage.Status.IN_TRANSIT));
                    }
                    if (boardRegistry.isComplete(transitBoardMessage.getOperationNumber(),
                            transitBoardMessage.getBoardName(), transitBoardMessage.getStepNumber())) {
                        return new MessageReply(MessageReply.Type.OKAY, new BoardStatusMessage(
                                transitBoardMessage.getBoardName(), BoardStatusMessage.Status.COMPLETE));
                    }
                    return new MessageReply(MessageReply.Type.OKAY, new BoardStatusMessage(
                            transitBoardMessage.getBoardName(), BoardStatusMessage.Status.UNKNOWN));
                }
            });
        case FETCH_BOARD_COMPLETION_STATUS:
            final BoardMessage compStatusBoardMessage = BoardMessage.getInstance(message.getPayload());
            return boardExecutor.submitTask(compStatusBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {
                            if (boardRegistry.isLocked(compStatusBoardMessage.getBoardName())) {
                                return new MessageReply(MessageReply.Type.OKAY,
                                        new BoardStatusMessage(compStatusBoardMessage.getBoardName(),
                                                BoardStatusMessage.Status.IN_TRANSIT));
                            }
                            return new MessageReply(MessageReply.Type.OKAY, new BoardStatusMessage(
                                    compStatusBoardMessage.getBoardName(), BoardStatusMessage.Status.COMPLETE));
                        }
                    });
        case START_SHUFFLE_AND_MOVE_BOARD_TO_NODE:
            final CopyAndMoveMessage startPandMmessage = CopyAndMoveMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(startPandMmessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    if (!boardRegistry.isShuffleLocked(startPandMmessage.getBoardName())) {
                        return new MessageReply(MessageReply.Type.ERROR,
                                new BoardErrorStatusMessage(startPandMmessage.getBoardName(),
                                        BoardErrorStatusMessage.Status.NOT_SHUFFLE_LOCKED));
                    }

                    nodeContext.execute(new CopyAndMoveTask(nodeContext, boardRegistry,
                            getPeerConnection(startPandMmessage.getDestinationNode()), startPandMmessage));

                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case SHUFFLE_AND_MOVE_BOARD_TO_NODE:
            final PermuteAndMoveMessage pAndmMessage = PermuteAndMoveMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(pAndmMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    nodeContext.execute(new TransformShuffleAndMoveTask(nodeContext, boardRegistry,
                            getPeerConnection(pAndmMessage.getDestinationNode()), pAndmMessage));

                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case RETURN_TO_BOARD:
            final TransitBoardMessage returnToBoardMessage = TransitBoardMessage
                    .getInstance(message.getPayload());

            return boardExecutor.submitTask(returnToBoardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    nodeContext
                            .execute(new ReturnToBoardTask(nodeContext, boardRegistry, returnToBoardMessage));
                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case INITIATE_INTRANSIT_BOARD:
            final TransitBoardMessage initiateTransitBoardMessage = TransitBoardMessage
                    .getInstance(message.getPayload());

            return boardExecutor.submitTask(initiateTransitBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() throws Exception {
                            boardRegistry.markInTransit(initiateTransitBoardMessage.getOperationNumber(),
                                    initiateTransitBoardMessage.getBoardName(),
                                    initiateTransitBoardMessage.getStepNumber());
                            boardRegistry.getTransitBoard(initiateTransitBoardMessage.getOperationNumber(),
                                    initiateTransitBoardMessage.getBoardName(),
                                    initiateTransitBoardMessage.getStepNumber()).clear();
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case TRANSFER_TO_BOARD:
            final BoardUploadBlockMessage uploadMessage = BoardUploadBlockMessage
                    .getInstance(message.getPayload());

            return boardExecutor.submitTask(uploadMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    boardRegistry.markInTransit(uploadMessage.getOperationNumber(),
                            uploadMessage.getBoardName(), uploadMessage.getStepNumber());
                    boardRegistry
                            .getTransitBoard(uploadMessage.getOperationNumber(), uploadMessage.getBoardName(),
                                    uploadMessage.getStepNumber())
                            .postMessageBlock(uploadMessage.getMessageBlock());
                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case UPLOAD_TO_BOARD:
            final BoardUploadBlockMessage uploadToBoardMessage = BoardUploadBlockMessage
                    .getInstance(message.getPayload());

            return boardExecutor.submitTask(uploadToBoardMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() {
                    boardRegistry.markInTransit(uploadToBoardMessage.getOperationNumber(),
                            uploadToBoardMessage.getBoardName(), uploadToBoardMessage.getStepNumber());
                    boardRegistry.getBoard(uploadToBoardMessage.getBoardName())
                            .postMessageBlock(uploadToBoardMessage.getMessageBlock());

                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        case CLEAR_BACKUP_BOARD:
            final BoardMessage backupBoardMessage = BoardMessage.getInstance(message.getPayload());

            return boardExecutor.submitBackupTask(backupBoardMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() {
                            // TODO: maybe backup the current backup locally?
                            boardRegistry.getBackupBoard(backupBoardMessage.getBoardName()).clear();
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case TRANSFER_TO_BACKUP_BOARD:
            final BoardUploadIndexedMessage uploadIndexedMessage = BoardUploadIndexedMessage
                    .getInstance(message.getPayload());

            return boardExecutor.submitBackupTask(uploadIndexedMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        @Override
                        public MessageReply call() {
                            boardRegistry.getBackupBoard(uploadIndexedMessage.getBoardName())
                                    .postMessages(uploadIndexedMessage.getData());
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case TRANSFER_TO_BOARD_ENDED:
            final TransitBoardMessage transferToBoardEndedMessage = TransitBoardMessage
                    .getInstance(message.getPayload());

            return boardExecutor.submitTask(transferToBoardEndedMessage.getBoardName(),
                    new Callable<MessageReply>() {
                        public MessageReply call() {
                            boardRegistry.markCompleted(transferToBoardEndedMessage.getOperationNumber(),
                                    transferToBoardEndedMessage.getBoardName(),
                                    transferToBoardEndedMessage.getStepNumber());
                            return new MessageReply(MessageReply.Type.OKAY,
                                    new DERUTF8String(nodeContext.getName()));
                        }
                    });
        case DOWNLOAD_BOARD_CONTENTS:
            final BoardDownloadMessage downloadRequest = BoardDownloadMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(downloadRequest.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() {
                    if (!boardRegistry.isDownloadLocked(downloadRequest.getBoardName())) {
                        return new MessageReply(MessageReply.Type.ERROR,
                                new BoardErrorStatusMessage(downloadRequest.getBoardName(),
                                        BoardErrorStatusMessage.Status.NOT_DOWNLOAD_LOCKED));
                    }

                    BulletinBoard board = boardRegistry.getBoard(downloadRequest.getBoardName());

                    PostedMessageBlock messages = board.removeMessages(
                            new PostedMessageBlock.Builder(downloadRequest.getMaxNumberOfMessages()));

                    return new MessageReply(MessageReply.Type.OKAY, messages);
                }
            });
        case DOWNLOAD_SHUFFLE_TRANSCRIPT:
            final TranscriptDownloadMessage transcriptDownloadMessage = TranscriptDownloadMessage
                    .getInstance(message.getPayload());
            final BulletinBoard transitBoard = boardRegistry.getTransitBoard(
                    transcriptDownloadMessage.getOperationNumber(), transcriptDownloadMessage.getStepNo());

            return boardExecutor.submitTask(transitBoard.getName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    boolean isCopyBoard = isCopyBoard(transitBoard);
                    String challengerKey = getChallengerKey(transcriptDownloadMessage,
                            isCopyBoard || (transitBoard.size() == 1));

                    IndexNumberGenerator challenger = challengers.get(challengerKey);
                    if (challenger == null) {
                        if (transitBoard.size() == 1) {
                            challenger = new SerialChallenger(1, transcriptDownloadMessage.getStepNo(),
                                    transcriptDownloadMessage.getSeed());
                        } else if (TranscriptType.GENERAL == transcriptDownloadMessage.getType()) {
                            challenger = new SerialChallenger(
                                    transitBoard.transcriptSize(TranscriptType.GENERAL),
                                    transcriptDownloadMessage.getStepNo(), transcriptDownloadMessage.getSeed());
                        } else {
                            SHA512Digest seedDigest = new SHA512Digest();
                            byte[] challengeSeed = new byte[seedDigest.getDigestSize()];

                            if (transcriptDownloadMessage.getSeed() != null) {
                                byte[] originalSeed = transcriptDownloadMessage.getSeed();

                                nodeContext.getEventNotifier().notify(EventNotifier.Level.INFO,
                                        "Original seed: " + new String(Hex.encode(originalSeed)));

                                // we follow the formulation in "Randomized Partial Checking Revisited" where the seed is
                                // modified by the step number, the one difference being that in our case this will only take
                                // place at the start of a pairing, or on an individual step.
                                seedDigest.update(originalSeed, 0, originalSeed.length);

                                int stepNo = transcriptDownloadMessage.getStepNo();

                                seedDigest.update((byte) (stepNo >>> 24));
                                seedDigest.update((byte) (stepNo >>> 16));
                                seedDigest.update((byte) (stepNo >>> 8));
                                seedDigest.update((byte) stepNo);

                                seedDigest.doFinal(challengeSeed, 0);
                            }

                            nodeContext.getEventNotifier().notify(EventNotifier.Level.INFO,
                                    "Challenge seed: " + transcriptDownloadMessage.getStepNo() + " "
                                            + new String(Hex.encode(challengeSeed)));

                            try {
                                if (isCopyBoard) {
                                    challenger = new SerialChallenger(
                                            transitBoard.transcriptSize(transcriptDownloadMessage.getType()),
                                            transcriptDownloadMessage.getStepNo(), challengeSeed);
                                } else if (transcriptDownloadMessage.isWithPairing()) {
                                    // TODO: maybe configure
                                    int chunkSize = 100;
                                    IndexNumberGenerator sourceGenerator = new SerialChallenger(
                                            transitBoard.size(), 0, null);
                                    int[] indexes = new int[transitBoard.size()];
                                    int count = 0;
                                    while (sourceGenerator.hasNext()) {
                                        TranscriptBlock transcript = transitBoard.fetchTranscriptData(
                                                TranscriptType.WITNESSES, sourceGenerator,
                                                new TranscriptBlock.Builder(0, chunkSize));

                                        for (Enumeration en = transcript.getDetails().getObjects(); en
                                                .hasMoreElements();) {
                                            PostedData msg = PostedData.getInstance(en.nextElement());

                                            indexes[count++] = MessageCommitment.getInstance(msg.getData())
                                                    .getNewIndex();
                                        }
                                    }

                                    challenger = new PairedChallenger(indexes,
                                            transcriptDownloadMessage.getStepNo(),
                                            (IndexNumberGenerator) witnessChallengerConstructor.newInstance(
                                                    transitBoard.transcriptSize(
                                                            transcriptDownloadMessage.getType()),
                                                    transcriptDownloadMessage.getStepNo(), challengeSeed));
                                } else {
                                    challenger = (IndexNumberGenerator) witnessChallengerConstructor
                                            .newInstance(
                                                    transitBoard.transcriptSize(
                                                            transcriptDownloadMessage.getType()),
                                                    transcriptDownloadMessage.getStepNo(), challengeSeed);
                                }
                            } catch (Exception e) {
                                nodeContext.getEventNotifier().notify(EventNotifier.Level.ERROR, e);

                                return new MessageReply(MessageReply.Type.ERROR, new ErrorMessage(
                                        "Unable to create challenger on " + nodeContext.getName()));
                            }
                        }
                        challengers.put(challengerKey, challenger);
                    }

                    if (challenger instanceof PairedChallenger) {
                        ((PairedChallenger) challenger).setStepNo(transcriptDownloadMessage.getStepNo());
                    }

                    TranscriptBlock transcriptBlock = transitBoard.fetchTranscriptData(
                            transcriptDownloadMessage.getType(), challenger,
                            new TranscriptBlock.Builder(transcriptDownloadMessage.getStepNo(),
                                    transcriptDownloadMessage.getMaxNumberOfMessages()));

                    String generatorKey = getTranscriptGeneratorKey(transcriptDownloadMessage);
                    TranscriptGenerator transGen = transcriptGenerators.get(generatorKey);
                    if (transGen == null) {
                        transGen = new TranscriptGenerator();

                        transcriptGenerators.put(generatorKey, transGen);
                    }

                    if (transcriptBlock.size() != 0) {
                        for (Enumeration en = transcriptBlock.getDetails().getObjects(); en
                                .hasMoreElements();) {
                            transGen.writeFragment(((ASN1Object) en.nextElement()).getEncoded());
                        }

                        return new MessageReply(MessageReply.Type.OKAY, new TranscriptTransferMessage(
                                transcriptBlock.getStepNo(), transGen.getFragment()));
                    }

                    if (transGen.hasData()) {
                        transGen.finish();
                        return new MessageReply(MessageReply.Type.OKAY, new TranscriptTransferMessage(
                                transcriptBlock.getStepNo(), transGen.getFragment()));
                    }

                    // end of data
                    return new MessageReply(MessageReply.Type.OKAY,
                            new TranscriptTransferMessage(transcriptBlock.getStepNo()));
                }
            });
        case DOWNLOAD_SHUFFLE_TRANSCRIPT_STEPS:
            final TranscriptQueryMessage transcriptQueryMessage = TranscriptQueryMessage
                    .getInstance(message.getPayload());

            FutureTask<MessageReply> dstsTask = new FutureTask(new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    List<String> transitBoardNames = boardRegistry
                            .getTransitBoardNames(transcriptQueryMessage.getOperationNumber());
                    int[] stepNos = new int[transitBoardNames.size()];
                    String boardName = "";

                    for (int i = 0; i != stepNos.length; i++) {
                        String name = transitBoardNames.get(i);
                        boardName = name.substring(name.indexOf('.') + 1, name.lastIndexOf('.'));

                        stepNos[i] = Integer.parseInt(name.substring(name.lastIndexOf('.') + 1));
                    }

                    return new MessageReply(MessageReply.Type.OKAY,
                            new TranscriptQueryResponse(queryCounter.incrementAndGet(), boardName, stepNos));
                }
            });

            nodeContext.getExecutorService().submit(dstsTask);

            return dstsTask;
        default:
            FutureTask<MessageReply> eTask = new FutureTask(new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    return new MessageReply(MessageReply.Type.ERROR, new ErrorMessage("Unknown command"));
                }
            });

            nodeContext.getExecutorService().submit(eTask);

            return eTask;
        }
    } else {
        switch (((ClientMessage) message).getType()) {
        case UPLOAD_TO_BOARD:
            final BoardUploadMessage uploadMessage = BoardUploadMessage.getInstance(message.getPayload());

            return boardExecutor.submitTask(uploadMessage.getBoardName(), new Callable<MessageReply>() {
                @Override
                public MessageReply call() {
                    if (boardRegistry.isLocked(uploadMessage.getBoardName())) {
                        return new MessageReply(MessageReply.Type.ERROR, new BoardErrorStatusMessage(
                                uploadMessage.getBoardName(), BoardErrorStatusMessage.Status.SUSPENDED));
                    }

                    byte[][] messages = uploadMessage.getData();

                    if (messages.length == 1) {
                        boardRegistry.getBoard(uploadMessage.getBoardName()).postMessage(messages[0]);
                    } else {
                        boardRegistry.getBoard(uploadMessage.getBoardName()).postMessages(messages);
                    }

                    return new MessageReply(MessageReply.Type.OKAY, new DERUTF8String(nodeContext.getName()));
                }
            });
        default:
            FutureTask<MessageReply> eTask = new FutureTask(new Callable<MessageReply>() {
                @Override
                public MessageReply call() throws Exception {
                    return new MessageReply(MessageReply.Type.ERROR, new DERUTF8String("Unknown command"));
                }
            });

            nodeContext.getExecutorService().submit(eTask);

            return eTask;
        }
    }
}

From source file:org.dcache.gridsite.BouncyCastleCredentialDelegation.java

License:Open Source License

private static X509Name buildProxyDN(X500Principal principal) throws GeneralSecurityException {
    ASN1StreamParser parser = new ASN1StreamParser(principal.getEncoded());

    DERSequence seq;//ww  w . ja v  a2 s . c om
    try {
        ASN1Encodable object = parser.readObject().getDERObject();
        if (!(object instanceof DERSequence)) {
            throw new IOException("not a DER-encoded ASN.1 sequence");
        }
        seq = (DERSequence) object;
    } catch (IOException e) {
        throw new GeneralSecurityException("failed to parse DN: " + e.getMessage());
    }

    List<ASN1Encodable> rdn = new ArrayList<>(seq.size() + 1);
    for (Enumeration e = seq.getObjects(); e.hasMoreElements();) {
        rdn.add((ASN1Encodable) e.nextElement());
    }

    DERSequence atv = new DERSequence(new ASN1Object[] { X509Name.CN, new DERPrintableString("proxy") });
    rdn.add(new DERSet(atv));

    ASN1Encodable[] rdnArray = rdn.toArray(new ASN1Encodable[rdn.size()]);
    return new X509Name(new DERSequence(rdnArray));
}

From source file:org.demoiselle.signer.policy.impl.cades.pkcs7.attribute.impl.CertificateRefs.java

License:Open Source License

@Override
public Attribute getValue() throws SignerException {

    try {//  w w  w  . j a va  2  s  .c  o  m
        int chainSize = certificates.length - 1;
        OtherCertID[] arrayOtherCertID = new OtherCertID[chainSize];
        for (int i = 1; i <= chainSize; i++) {
            X509Certificate issuerCert = null;
            X509Certificate cert = (X509Certificate) certificates[i];
            if (i < chainSize) {
                issuerCert = (X509Certificate) certificates[i + 1];
            } else { // raiz
                issuerCert = (X509Certificate) certificates[i];
            }
            Digest digest = DigestFactory.getInstance().factoryDefault();
            digest.setAlgorithm(DigestAlgorithmEnum.SHA_256);
            byte[] certHash = digest.digest(cert.getEncoded());
            X500Name dirName = new X500Name(issuerCert.getSubjectX500Principal().getName());
            GeneralName name = new GeneralName(dirName);
            GeneralNames issuer = new GeneralNames(name);
            ASN1Integer serialNumber = new ASN1Integer(cert.getSerialNumber());
            IssuerSerial issuerSerial = new IssuerSerial(issuer, serialNumber);
            AlgorithmIdentifier algId = new AlgorithmIdentifier(NISTObjectIdentifiers.id_sha256);
            OtherCertID otherCertID = new OtherCertID(algId, certHash, issuerSerial);
            arrayOtherCertID[i - 1] = otherCertID;
        }

        return new Attribute(new ASN1ObjectIdentifier(identifier),
                new DERSet(new ASN1Encodable[] { new DERSequence(arrayOtherCertID) }));
    } catch (CertificateEncodingException e) {
        throw new SignerException(e.getMessage());
    }
}

From source file:org.demoiselle.signer.policy.impl.cades.pkcs7.attribute.impl.CertValues.java

License:Open Source License

@Override
public Attribute getValue() throws SignerException {

    List<org.bouncycastle.asn1.x509.Certificate> certificateValues = new ArrayList<org.bouncycastle.asn1.x509.Certificate>();
    try {//from  w w  w  .  j av a 2  s. c  om

        int chainSize = certificates.length - 1;
        for (int i = 0; i < chainSize; i++) {
            X509Certificate cert = (X509Certificate) certificates[i];
            byte data[] = cert.getEncoded();
            certificateValues.add(org.bouncycastle.asn1.x509.Certificate.getInstance(data));
        }
        org.bouncycastle.asn1.x509.Certificate[] certValuesArray = new org.bouncycastle.asn1.x509.Certificate[certificateValues
                .size()];
        return new Attribute(new ASN1ObjectIdentifier(identifier),
                new DERSet(new DERSequence(certificateValues.toArray(certValuesArray))));
    } catch (CertificateEncodingException e) {
        throw new SignerException(e.getMessage());
    }
}

From source file:org.demoiselle.signer.policy.impl.cades.pkcs7.attribute.impl.RevocationRefs.java

License:Open Source License

@Override
public Attribute getValue() throws SignerException {

    try {/*from w  ww.  j ava  2 s .com*/

        int chainSize = certificates.length - 1;
        ArrayList<CrlValidatedID> crls = new ArrayList<CrlValidatedID>();
        for (int ix = 0; ix < chainSize; ix++) {
            X509Certificate cert = (X509Certificate) certificates[ix];
            Collection<ICPBR_CRL> icpCrls = crlRepository.getX509CRL(cert);
            for (ICPBR_CRL icpCrl : icpCrls) {
                crls.add(makeCrlValidatedID(icpCrl.getCRL()));
            }
        }
        int crlsIdSize = crls.size();
        CrlValidatedID[] crlsForId = new CrlValidatedID[crlsIdSize];
        int i = 0;
        for (CrlValidatedID crlVID : crls) {
            crlsForId[i] = crlVID;
            i++;
        }
        //CrlListID crlids = new CrlListID(crlsForId);

        DERSequence crlValidatedIDSeq = new DERSequence(crlsForId);
        //--CRLListID--/
        ASN1Encodable[] crlValidatedIDSeqArr = new ASN1Encodable[1];
        crlValidatedIDSeqArr[0] = crlValidatedIDSeq;
        DERSequence crlListID = new DERSequence(crlValidatedIDSeqArr);
        // CRLListID--/
        DERTaggedObject crlListIDTagged = new DERTaggedObject(0, crlListID);
        // CrlOcspRef--/
        ASN1Encodable[] crlListIDTaggedArr = new ASN1Encodable[1];
        crlListIDTaggedArr[0] = crlListIDTagged;
        DERSequence crlOscpRef = new DERSequence(crlListIDTaggedArr);
        //--CompleteRevocationRefs--/
        ASN1Encodable[] crlOscpRefArr = new ASN1Encodable[1];
        crlOscpRefArr[0] = crlOscpRef;
        DERSequence completeRevocationRefs = new DERSequence(crlOscpRefArr);

        // TODO - OCSP - opcional
        /*
        BasicCertificate basicCert = new BasicCertificate(cert);
        List<String> ListaURLCRL = basicCert.getCRLDistributionPoint();
        OcspResponsesID[] ocspResponsesIDArray = new OcspResponsesID[chainSize];
        for (int i = 0; i < chainSize; i++ ){           
           OcspClientBouncyCastle client = new OcspClientBouncyCastle(null);
             X509Certificate checkCert = (X509Certificate) certificates[i];
             X509Certificate rootCert = (X509Certificate)  certificates[chainSize]; 
             String crlUrl = ListaURLCRL.get(i);
             //BasicOCSPResp ocspResp =  client.getBasicOCSPResp(checkCert,rootCert,crlUrl);           
             BasicOCSPResp ocspResp =  client.getBasicOCSPResp(checkCert,rootCert, null);
             ocspResponsesIDArray[i] = makeOcspResponsesID(ocspResp);           
        } 
                  
        OcspListID ocspids = new OcspListID(ocspResponsesIDArray);
        */

        //CrlOcspRef crlOcspRef = new CrlOcspRef(crlids, ocspids, null);
        //OtherRevRefs OtherRevRefs = new OtherRevRefs(null, OtherRevRefs);
        //CrlOcspRef crlOcspRef = new CrlOcspRef(crlids, null, null);
        return new Attribute(new ASN1ObjectIdentifier(identifier), new DERSet(completeRevocationRefs));
        // CrlOcspRef[] crlOcspRefArray = new
        // CrlOcspRef[completeRevocationRefs.size()];

    } catch (NoSuchAlgorithmException | CRLException e) {
        throw new SignerException(e.getMessage());
    }

}

From source file:org.demoiselle.signer.policy.impl.cades.pkcs7.attribute.impl.RevocationValues.java

License:Open Source License

@Override
public Attribute getValue() throws SignerException {
    List<X509CRL> crlList = new ArrayList<X509CRL>();
    ArrayList<CertificateList> crlVals = new ArrayList<CertificateList>();
    List<BasicOCSPResponse> ocspVals = new ArrayList<BasicOCSPResponse>();
    try {/*from  www .ja  va 2s. c o  m*/

        int chainSize = certificates.length - 1;
        for (int ix = 0; ix < chainSize; ix++) {
            X509Certificate cert = (X509Certificate) certificates[ix];
            Collection<ICPBR_CRL> icpCrls = crlRepository.getX509CRL(cert);
            for (ICPBR_CRL icpCrl : icpCrls) {
                crlList.add(icpCrl.getCRL());
            }
        }
        if (crlList.isEmpty()) {
            throw new SignerException(cadesMessagesBundle.getString("error.crl.list.empty"));
        } else {
            for (X509CRL varCrl : crlList) {
                crlVals.add(CertificateList.getInstance(varCrl.getEncoded()));

            }
        }
        CertificateList[] crlValuesArray = new CertificateList[crlVals.size()];
        BasicOCSPResponse[] ocspValuesArray = new BasicOCSPResponse[ocspVals.size()];
        //   OtherRevVals otherRevVals = new OtherRevVals(null);
        //return new Attribute(new ASN1ObjectIdentifier(identifier),   new DERSet(null));
        //org.bouncycastle.asn1.esf.RevocationValues revocationVals = new org.bouncycastle.asn1.esf.RevocationValues(crlVals.toArray(crlValuesArray), ocspVals.toArray(ocspValuesArray), null);
        //org.bouncycastle.asn1.esf.RevocationValues revocationVals = new org.bouncycastle.asn1.esf.RevocationValues(crlVals.toArray(crlValuesArray), null, null);
        return new Attribute(new ASN1ObjectIdentifier(identifier),
                new DERSet(new DERSequence(crlVals.toArray(crlValuesArray))));
    } catch (Exception e) {
        throw new SignerException(e.getMessage());
    }
}

From source file:org.demoiselle.signer.policy.impl.cades.pkcs7.attribute.impl.SigningCertificate.java

License:Open Source License

@Override
public Attribute getValue() {
    try {/*from   w  w w.  ja  va2s. c o  m*/
        X509Certificate cert = (X509Certificate) certificates[0];
        Digest digest = DigestFactory.getInstance().factoryDefault();
        digest.setAlgorithm(DigestAlgorithmEnum.SHA_1);
        byte[] hash = digest.digest(cert.getEncoded());
        X500Name dirName = new X500Name(cert.getSubjectDN().getName());
        GeneralName name = new GeneralName(dirName);
        GeneralNames issuer = new GeneralNames(name);
        ASN1Integer serial = new ASN1Integer(cert.getSerialNumber());
        IssuerSerial issuerSerial = new IssuerSerial(issuer, serial);
        ESSCertID essCertId = new ESSCertID(hash, issuerSerial);
        return new Attribute(new ASN1ObjectIdentifier(identifier), new DERSet(new DERSequence(
                new ASN1Encodable[] { new DERSequence(essCertId), new DERSequence(DERNull.INSTANCE) })));

    } catch (CertificateEncodingException ex) {
        throw new SignerException(ex.getMessage());
    }
}

From source file:org.demoiselle.signer.policy.impl.cades.pkcs7.attribute.impl.SigningCertificateV2.java

License:Open Source License

@Override
public Attribute getValue() throws SignerException {
    try {/*from   w w w  . jav a  2  s  .c  o  m*/
        X509Certificate cert = (X509Certificate) certificates[0];
        X509Certificate issuerCert = (X509Certificate) certificates[1];
        Digest digest = DigestFactory.getInstance().factoryDefault();
        digest.setAlgorithm(DigestAlgorithmEnum.SHA_256);
        byte[] certHash = digest.digest(cert.getEncoded());
        X500Name dirName = new X500Name(issuerCert.getSubjectX500Principal().getName());
        GeneralName name = new GeneralName(dirName);
        GeneralNames issuer = new GeneralNames(name);
        ASN1Integer serialNumber = new ASN1Integer(cert.getSerialNumber());
        IssuerSerial issuerSerial = new IssuerSerial(issuer, serialNumber);
        AlgorithmIdentifier algId = new AlgorithmIdentifier(NISTObjectIdentifiers.id_sha256);// SHA-256
        ESSCertIDv2 essCertIDv2 = new ESSCertIDv2(algId, certHash, issuerSerial);
        //         return new Attribute(new ASN1ObjectIdentifier(identifier), new DERSet(new DERSequence(essCertIDv2)));
        return new Attribute(new ASN1ObjectIdentifier(identifier),
                new DERSet(new DERSequence(new ASN1Encodable[] { new DERSequence(essCertIDv2) })));
    } catch (CertificateEncodingException ex) {
        throw new SignerException(ex.getMessage());
    }
}

From source file:org.deviceconnect.android.ssl.CertificateAuthority.java

License:MIT License

/**
 * ???? Subject Alternative Names (SANs) ??.
 *
 * @param request ???//from w w w  .  j ava  2s.  c o m
 * @return SubjectAlternativeNames? {@link GeneralNames} 
 * @throws IOException ?????
 */
private GeneralNames parseSANs(final PKCS10CertificationRequest request) throws IOException {
    List<ASN1Encodable> generalNames = new ArrayList<>();

    CertificationRequestInfo info = request.getCertificationRequestInfo();
    ASN1Set attributes = info.getAttributes();
    for (int i = 0; i < attributes.size(); i++) {
        DEREncodable extensionRequestObj = attributes.getObjectAt(i);
        if (!(extensionRequestObj instanceof DERSequence)) {
            continue;
        }
        DERSequence extensionRequest = (DERSequence) extensionRequestObj;
        if (extensionRequest.size() != 2) {
            continue;
        }
        DEREncodable idObj = extensionRequest.getObjectAt(0);
        DEREncodable contentObj = extensionRequest.getObjectAt(1);
        if (!(idObj instanceof ASN1ObjectIdentifier && contentObj instanceof DERSet)) {
            continue;
        }
        ASN1ObjectIdentifier id = (ASN1ObjectIdentifier) idObj;
        DERSet content = (DERSet) contentObj;
        if (!id.getId().equals("1.2.840.113549.1.9.14")) {
            continue;
        }
        if (content.size() < 1) {
            continue;
        }
        DEREncodable extensionsObj = content.getObjectAt(0);
        if (!(extensionsObj instanceof DERSequence)) {
            continue;
        }
        DERSequence extensions = (DERSequence) extensionsObj;

        for (int k = 0; k < extensions.size(); k++) {
            DEREncodable extensionObj = extensions.getObjectAt(k);
            if (!(extensionObj instanceof DERSequence)) {
                continue;
            }
            DERSequence extension = (DERSequence) extensionObj;
            if (extension.size() != 2) {
                continue;
            }
            DEREncodable extensionIdObj = extension.getObjectAt(0);
            DEREncodable extensionContentObj = extension.getObjectAt(1);
            if (!(extensionIdObj instanceof ASN1ObjectIdentifier)) {
                continue;
            }
            ASN1ObjectIdentifier extensionId = (ASN1ObjectIdentifier) extensionIdObj;
            if (extensionId.getId().equals("2.5.29.17")) {
                DEROctetString san = (DEROctetString) extensionContentObj;

                ASN1StreamParser sanParser = new ASN1StreamParser(san.parser().getOctetStream());
                DEREncodable namesObj = sanParser.readObject().getDERObject();
                if (namesObj instanceof DERSequence) {
                    DERSequence names = (DERSequence) namesObj;
                    for (int m = 0; m < names.size(); m++) {
                        DEREncodable nameObj = names.getObjectAt(m);
                        if (nameObj instanceof DERTaggedObject) {
                            DERTaggedObject name = (DERTaggedObject) nameObj;
                            switch (name.getTagNo()) {
                            case GeneralName.dNSName:
                                generalNames.add(new GeneralName(GeneralName.dNSName,
                                        DERIA5String.getInstance(name, false)));
                                break;
                            case GeneralName.iPAddress:
                                generalNames.add(new GeneralName(GeneralName.iPAddress,
                                        DEROctetString.getInstance(name, true)));
                                break;
                            }
                        }
                    }
                }
            }
        }
    }
    if (generalNames.size() > 0) {
        return new GeneralNames(new DERSequence(generalNames.toArray(new ASN1Encodable[generalNames.size()])));
    }
    return null;
}