コード例 #1
0
ファイル: PdfAppendTest.java プロジェクト: Rabeea/camel
  @Test
  public void testAppendEncrypted() throws Exception {
    final String originalText = "Test";
    final String textToAppend = "Append";
    PDDocument document = new PDDocument();
    PDPage page = new PDPage(PDPage.PAGE_SIZE_A4);
    document.addPage(page);
    PDPageContentStream contentStream = new PDPageContentStream(document, page);
    contentStream.setFont(PDType1Font.HELVETICA, 12);
    contentStream.beginText();
    contentStream.moveTextPositionByAmount(20, 400);
    contentStream.drawString(originalText);
    contentStream.endText();
    contentStream.close();

    final String ownerPass = "******";
    final String userPass = "******";
    AccessPermission accessPermission = new AccessPermission();
    accessPermission.setCanExtractContent(false);
    StandardProtectionPolicy protectionPolicy =
        new StandardProtectionPolicy(ownerPass, userPass, accessPermission);
    protectionPolicy.setEncryptionKeyLength(128);

    document.protect(protectionPolicy);

    ByteArrayOutputStream output = new ByteArrayOutputStream();
    document.save(output);

    // Encryption happens after saving.
    PDDocument encryptedDocument = PDDocument.load(new ByteArrayInputStream(output.toByteArray()));

    Map<String, Object> headers = new HashMap<String, Object>();
    headers.put(PdfHeaderConstants.PDF_DOCUMENT_HEADER_NAME, encryptedDocument);
    headers.put(
        PdfHeaderConstants.DECRYPTION_MATERIAL_HEADER_NAME,
        new StandardDecryptionMaterial(userPass));

    template.sendBodyAndHeaders("direct:start", textToAppend, headers);

    resultEndpoint.setExpectedMessageCount(1);
    resultEndpoint.expectedMessagesMatches(
        new Predicate() {
          @Override
          public boolean matches(Exchange exchange) {
            Object body = exchange.getIn().getBody();
            assertThat(body, instanceOf(ByteArrayOutputStream.class));
            try {
              PDDocument doc =
                  PDDocument.load(
                      new ByteArrayInputStream(((ByteArrayOutputStream) body).toByteArray()));
              PDFTextStripper pdfTextStripper = new PDFTextStripper();
              String text = pdfTextStripper.getText(doc);
              assertEquals(2, doc.getNumberOfPages());
              assertThat(text, containsString(originalText));
              assertThat(text, containsString(textToAppend));
            } catch (IOException e) {
              throw new RuntimeException(e);
            }
            return true;
          }
        });
    resultEndpoint.assertIsSatisfied();
  }
コード例 #2
0
ファイル: Encrypt.java プロジェクト: Spirals-Team/npe-dataset
  private void encrypt(String[] args) throws Exception {
    if (args.length < 1) {
      usage();
    } else {
      AccessPermission ap = new AccessPermission();

      String infile = null;
      String outfile = null;
      String certFile = null;
      String userPassword = "";
      String ownerPassword = "";

      int keyLength = 40;

      PDDocument document = null;

      try {
        for (int i = 0; i < args.length; i++) {
          String key = args[i];
          if (key.equals("-O")) {
            ownerPassword = args[++i];
          } else if (key.equals("-U")) {
            userPassword = args[++i];
          } else if (key.equals("-canAssemble")) {
            ap.setCanAssembleDocument(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canExtractContent")) {
            ap.setCanExtractContent(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canExtractForAccessibility")) {
            ap.setCanExtractForAccessibility(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canFillInForm")) {
            ap.setCanFillInForm(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canModify")) {
            ap.setCanModify(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canModifyAnnotations")) {
            ap.setCanModifyAnnotations(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canPrint")) {
            ap.setCanPrint(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-canPrintDegraded")) {
            ap.setCanPrintDegraded(args[++i].equalsIgnoreCase("true"));
          } else if (key.equals("-certFile")) {
            certFile = args[++i];
          } else if (key.equals("-keyLength")) {
            try {
              keyLength = Integer.parseInt(args[++i]);
            } catch (NumberFormatException e) {
              throw new NumberFormatException(
                  "Error: -keyLength is not an integer '" + args[i] + "'");
            }
          } else if (infile == null) {
            infile = key;
          } else if (outfile == null) {
            outfile = key;
          } else {
            usage();
          }
        }
        if (infile == null) {
          usage();
        }
        if (outfile == null) {
          outfile = infile;
        }
        document = PDDocument.load(infile);

        if (!document.isEncrypted()) {
          if (certFile != null) {
            PublicKeyProtectionPolicy ppp = new PublicKeyProtectionPolicy();
            PublicKeyRecipient recip = new PublicKeyRecipient();
            recip.setPermission(ap);

            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            InputStream inStream = new FileInputStream(certFile);
            X509Certificate certificate = (X509Certificate) cf.generateCertificate(inStream);
            inStream.close();

            recip.setX509(certificate);

            ppp.addRecipient(recip);

            ppp.setEncryptionKeyLength(keyLength);

            document.protect(ppp);
          } else {
            StandardProtectionPolicy spp =
                new StandardProtectionPolicy(ownerPassword, userPassword, ap);
            spp.setEncryptionKeyLength(keyLength);
            document.protect(spp);
          }
          document.save(outfile);
        } else {
          System.err.println("Error: Document is already encrypted.");
        }
      } finally {
        if (document != null) {
          document.close();
        }
      }
    }
  }