Example usage for com.lowagie.text.pdf PdfName NAME

Introduction

In this page you can find the example usage for com.lowagie.text.pdf PdfName NAME.

Prototype

PdfName NAME

To view the source code for com.lowagie.text.pdf PdfName NAME.

Click Source Link

Document

A name

Usage

From source file:androidGLUESigner.pdf.PDFSigExtractor.java

License:Open Source License

/**
 * extracts the signature field for previewing.
 * @throws IOException // ww w .j a  va  2 s  . c  om
 */
public static ArrayList<SignatureInfo> getSignatureInfo(String inputPath) {
    PdfReader reader;
    try {
        reader = new PdfReader(inputPath);
    } catch (IOException e) {
        return new ArrayList<SignatureInfo>();
    }
    AcroFields af = reader.getAcroFields();
    ArrayList names = af.getSignatureNames();
    ArrayList<SignatureInfo> signatures = new ArrayList<SignatureInfo>();
    // For every signature :
    for (int k = 0; k < names.size(); ++k) {
        String name = (String) names.get(k);
        SignatureInfo sigInfo = new SignatureInfo();
        // get coordinates
        float[] position = af.getFieldPositions(name);
        // page number
        float page = position[0];
        // left
        float llx = position[1];
        // bottom
        float lly = position[2];
        // right
        float urx = position[3];
        // top
        float ury = position[4];

        // get size of pdf page
        Rectangle size = reader.getPageSize((int) page);
        float height = size.getHeight();
        // subtract height to translate to Android canvas coordinate system
        lly = height - lly;
        ury = height - ury;
        float ulx = llx;

        // create a Rectangle from obtained signature field coordinates
        Rect sigRect = new Rect((int) ulx, (int) ury, (int) urx, (int) lly);
        sigInfo.setGraphicRect(sigRect, 1.0f);
        // obtain additional information like reason, location, ...
        PdfDictionary sig = af.getSignatureDictionary(name);
        sigInfo.setSignatureName(sig.getAsString(PdfName.NAME).toString());
        sigInfo.setSignatureLocation(sig.getAsString(PdfName.LOCATION).toString());
        sigInfo.setSignatureReason(sig.getAsString(PdfName.REASON).toString());
        sigInfo.setSignatureType(SignatureType.NORMAL);
        sigInfo.setPageNumber((int) page);
        // add new signature information to signatures
        signatures.add(sigInfo);
    }
    return signatures;
}

---

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText2Extractor.java

License:LGPL

/**
 * @param fullExportDirectoryPath//from   w w w.j ava  2s  . c  o m
 * @param pdfObjectCounter
 * @param pdfObject
 * @throws IOException
 * @throws Exception
 * @throws FileNotFoundException
 */
private void extractImageFromPdfObject(String fullExportDirectoryPath, int pdfObjectCounter,
        PdfObject pdfObject) throws IOException, Exception, FileNotFoundException {
    boolean rawByteArray = false;

    if (pdfObject != null) {
        if (pdfObject.isStream()) {
            PdfStream pdfStream = (PdfStream) pdfObject;
            PdfObject pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);

            // Check PDF subtype and make sure it's an Image type
            if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                // Now we have a PDF stream object with an image but what is that exactly?
                byte[] byteArrayImage = null;

                /*
                 * DCTDecode isn't supported by iText2.
                 * The image can be treated as JPEG (we have already
                 * verified it's an image):
                 * http://www.mail-archive.com/itext-questions@lists.sourceforge.net/msg48307.html
                 * 
                 * Check what kind of decoding has to be applied...and
                 * get the byte array containing the image.
                 */
                if ((pdfStream.get(PdfName.FILTER)).toString().equals(PdfName.DCTDECODE.toString())) {
                    // Get the RAW byte array
                    byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    rawByteArray = true;
                } else {
                    /*
                     * PdfReader.getStreamBytes(PRStream) should
                     * automatically apply all decoding filters.
                     * @see com.lowagie.text.pdf.PdfReader#getStreamBytes(PRStream)
                     */
                    byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                    rawByteArray = false;
                }

                /*
                // Test PdfImage - START
                logger.trace("");
                logger.trace("");
                        
                if (pdfStream instanceof PdfImage) {
                   PdfImage pdfImage = (PdfImage) pdfStream;
                   logger.trace("");
                   logger.trace("Output for pdfImage object...");
                   logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                   logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                   logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                   logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                   logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                   logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                   logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                   logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                   logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                } else {
                   logger.trace("pdfStream is NO instanceof PdfImage");
                }
                        
                // STREAM
                logger.trace("");
                logger.trace("Output for pdfImage object...");
                logger.trace("pdfObject.toString()).....................: " + pdfObject.toString());
                logger.trace("pdfObjectCounter..........................: " + pdfObjectCounter);
                logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream. get(PdfName.PAGE));
                logger.trace("pdfObject.getIndRef().getNumber().........: " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                logger.trace("pdfStream.getIndRef().getNumber().........: " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                */

                // Extract the image name
                String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                        : pdfStream.get(PdfName.NAME).toString());
                if (streamImageName != null && streamImageName.length() > 1
                        && streamImageName.startsWith("/")) {
                    streamImageName = streamImageName.substring(1);
                } else {
                    streamImageName = null;
                } // end if..else

                String exportFileWithoutExtension = (fullExportDirectoryPath != null ? fullExportDirectoryPath
                        : this.fullPDFDirectoryPath)
                        + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000" + "_ref"
                        + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                        + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                // Test
                FileOutputStream fileOutputStream = null;

                if (rawByteArray) {
                    fileOutputStream = new FileOutputStream(exportFileWithoutExtension + ".jpg");
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;
                } else {
                    /* 
                     * Check image details
                     */
                    int pdfImageWidth = -1;
                    int pdfImageHeight = -1;
                    int pdfImageBitsPerComponent = -1;

                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting BITSPERCOMPONENT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting HEIGHT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting WIDTH (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else {
                        logger.error("Unsupported Image format or missing information to convert the image.");
                    } // end if..else
                }
            } // end if
        } // end if 
    } // end if
}

---

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText2Extractor.java

License:LGPL

/**
 * @param fullExportDirectoryPath/*from  w  ww  .j a  v  a 2 s . co  m*/
 * @param pdfObjectCounter
 * @param pdfObject
 * @throws IOException
 * @throws Exception
 * @throws FileNotFoundException
 */
private void extractImageFromPdfObjectExperimental(String fullExportDirectoryPath, int pdfObjectCounter,
        PdfObject pdfObject) throws IOException, Exception, FileNotFoundException {
    boolean rawByteArray = false;

    if (pdfObject != null) {
        if (pdfObject.isStream()) {
            //|| pdfObject.isDictionary()) {
            //PdfObject pdfObjectSubType = null;
            ////PdfName pdfObjectSubType = null;
            ////PdfStream pdfStream = null;

            //if (pdfObject.isStream()) {
            PdfStream pdfStream = (PdfStream) pdfObject;
            //pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);
            PdfName pdfObjectSubType = (PdfName) PdfReader.getPdfObject(pdfStream.get(PdfName.SUBTYPE)); // J.U. - 2011-08-22

            /*               
                        } else if (pdfObject.isDictionary()) {
                           PdfDictionary pdfDictionary = (PdfDictionary)PdfReader.getPdfObject(pdfObject);
                           //PdfName pdfObjectSubType = (PdfName)PdfReader.getPdfObject(pdfDictionary.get(PdfName.SUBTYPE));
                           pdfObjectSubType = (PdfName)PdfReader.getPdfObject(pdfDictionary.get(PdfName.SUBTYPE));
                           if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                              int xRefIndex = pdfObject.getIndRef().getNumber();
                              PdfObject innerPdfObject = 
                           }
                        }
            */

            // Check PDF subtype and make sure it's an Image type
            if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                // Now we have a PDF stream object with an image but what is that exactly?
                byte[] byteArrayImage = null;

                /*
                 * DCTDecode isn't supported by iText2.
                 * The image can be treated as JPEG (we have already
                 * verified it's an image):
                 * http://www.mail-archive.com/itext-questions@lists.sourceforge.net/msg48307.html
                 * 
                 * Check what kind of decoding has to be applied...and
                 * get the byte array containing the image.
                 */
                if ((pdfStream.get(PdfName.FILTER)).toString().equals(PdfName.DCTDECODE.toString())) {
                    // Get the RAW byte array
                    byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    rawByteArray = true;
                } else {
                    /*
                     * PdfReader.getStreamBytes(PRStream) should
                     * automatically apply all decoding filters.
                     * @see com.lowagie.text.pdf.PdfReader#getStreamBytes(PRStream)
                     */
                    byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                    rawByteArray = false;
                }

                /*
                // Test PdfImage - START
                logger.trace("");
                logger.trace("");
                        
                if (pdfStream instanceof PdfImage) {
                   PdfImage pdfImage = (PdfImage) pdfStream;
                   logger.trace("");
                   logger.trace("Output for pdfImage object...");
                   logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                   logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                   logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                   logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                   logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                   logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                   logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                   logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                   logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                } else {
                   logger.trace("pdfStream is NO instanceof PdfImage");
                }
                        
                // STREAM
                logger.trace("");
                logger.trace("Output for pdfImage object...");
                logger.trace("pdfObject.toString()).....................: " + pdfObject.toString());
                logger.trace("pdfObjectCounter..........................: " + pdfObjectCounter);
                logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream. get(PdfName.PAGE));
                logger.trace("pdfObject.getIndRef().getNumber().........: " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                logger.trace("pdfStream.getIndRef().getNumber().........: " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                */

                // Extract the image name
                String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                        : pdfStream.get(PdfName.NAME).toString());
                if (streamImageName != null && streamImageName.length() > 1
                        && streamImageName.startsWith("/")) {
                    streamImageName = streamImageName.substring(1);
                } else {
                    streamImageName = null;
                } // end if..else

                String exportFileWithoutExtension = (fullExportDirectoryPath != null ? fullExportDirectoryPath
                        : this.fullPDFDirectoryPath)
                        + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000" + "_ref"
                        + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                        + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                // Test
                FileOutputStream fileOutputStream = null;

                if (rawByteArray) {
                    fileOutputStream = new FileOutputStream(exportFileWithoutExtension + ".jpg");
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;
                } else {
                    /* 
                     * Check image details
                     */
                    int pdfImageWidth = -1;
                    int pdfImageHeight = -1;
                    int pdfImageBitsPerComponent = -1;

                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting BITSPERCOMPONENT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting HEIGHT (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                        logger.error("A NumberFormatException occurred " + "converting WIDTH (w="
                                + pdfImageWidth + "; h=" + pdfImageHeight + "; BitsPerComponent="
                                + pdfImageBitsPerComponent + ".", ex);
                    }

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else {
                        logger.error("Unsupported Image format or missing information to convert the image.");
                    } // end if..else
                }
            } // end if
        } // end if 
    } // end if
}

---

From source file:de.offis.health.icardea.cied.pdf.extractor.PDFiText4Extractor.java

License:LGPL

/**
 * <p>//from   w  w  w.ja  va2  s .c o  m
 * This method searches for all image objects from the currently processed
 * PDF file and stores them as PDF in the given export directory or in the
 * same directory where the original PDF file is stored.
 * </p>
 * <p>
 * The filename of the images is build based on the original PDF filename
 * (without extension) and additional details like page number, image
 * number and if available the internal image name.
 * </p>
 * @param fullExportDirectoryPath The optional full export path where the images
 * should be stored. If not given, the location of the original PDF file is used.
 * @throws Exception
 */
private void imageExtractor(String fullExportDirectoryPath) throws Exception {
    if (fullExportDirectoryPath != null) {
        fullExportDirectoryPath = GlobalTools.checkDirectoryPath(fullExportDirectoryPath);
        File exportDirectory = new File(fullExportDirectoryPath);
        if (!exportDirectory.exists()) {
            exportDirectory.mkdirs();
        } // end if
    } // end if

    int totalNumberOfPDFObjects = pdfReader.getXrefSize();
    for (int pdfObjectCounter = 0; pdfObjectCounter < totalNumberOfPDFObjects; pdfObjectCounter++) {
        PdfObject pdfObject = pdfReader.getPdfObject(pdfObjectCounter);
        if (pdfObject != null) {
            if (pdfObject.isStream()) {
                PdfStream pdfStream = (PdfStream) pdfObject;
                PdfObject pdfObjectSubType = pdfStream.get(PdfName.SUBTYPE);

                if (pdfObject == null) {
                    logger.debug("The internal PDF object is null.");
                } // end if

                if (!pdfObject.isStream()) {
                    logger.debug("The internal PDF object is not representing a stream object.");
                } // end if

                // Check PDF subtype and make sure it's an Image type
                if (pdfObjectSubType != null && pdfObjectSubType.toString().equals(PdfName.IMAGE.toString())) {
                    // Now we have a PDF stream object with an image but what is that exactly?
                    //byte[] byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    byte[] byteArrayImage = null;
                    if (PdfName.FLATEDECODE.equals(pdfStream.getAsName(PdfName.FILTER))) {
                        byteArrayImage = PdfReader.getStreamBytes((PRStream) pdfStream);
                        // else if other filter (not supported yet)
                    } else {
                        byteArrayImage = PdfReader.getStreamBytesRaw((PRStream) pdfStream);
                    } // end if..else

                    // Test PdfImage - START
                    /*
                    PdfImage pdfImage = (PdfImage) ((PdfStream)((PRStream)pdfStream));
                    logger.trace("pdfImage --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                    logger.trace("pdfImage --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                    logger.trace("pdfImage --> pdfName --> Id..............: " + pdfImage.get(PdfName.ID));
                    logger.trace("pdfImage --> pdfName --> Image...........: " + pdfImage.get(PdfName.IMAGE));
                    logger.trace("pdfImage --> pdfName --> ImageB..........: " + pdfImage.get(PdfName.IMAGEB));
                    logger.trace("pdfImage --> pdfName --> ImageC..........: " + pdfImage.get(PdfName.IMAGEC));
                    logger.trace("pdfImage --> pdfName --> ImageI..........: " + pdfImage.get(PdfName.IMAGEI));
                    logger.trace("pdfImage --> pdfName --> Imagemask.......: " + pdfImage.get(PdfName.IMAGEMASK));
                    logger.trace("pdfImage --> pdfName --> Info............: " + pdfImage.get(PdfName.INFO));
                    logger.trace("pdfImage --> pdfName --> Name............: " + pdfImage.get(PdfName.NAME));
                    logger.trace("pdfImage --> pdfName --> Named...........: " + pdfImage.get(PdfName.NAMED));
                    logger.trace("pdfImage --> pdfName --> Page............: " + pdfStream.get(PdfName.PAGE));
                    */
                    // Test PdfImage - STOP

                    // STREAM
                    /*
                    logger.trace("pdfObject.toString()): " + pdfObject.toString());
                    logger.trace("pdfObjectCounter.................: " + pdfObjectCounter);
                    logger.trace("pdfObject.getIndRef().getNumber(): " + (pdfObject.getIndRef()!=null?pdfObject.getIndRef().toString():"null"));
                    logger.trace("pdfStream.getIndRef().getNumber(): " + (pdfStream.getIndRef()!=null?pdfStream.getIndRef().toString():"null"));
                    logger.trace("pdfStream --> pdfName --> toString........: " + pdfStream.toString());
                    logger.trace("pdfStream --> pdfName --> Width...........: " + pdfStream.get(PdfName.WIDTH));
                    logger.trace("pdfStream --> pdfName --> Height..........: " + pdfStream.get(PdfName.HEIGHT));
                    logger.trace("pdfStream --> pdfName --> BitsPerComponent: " + pdfStream.get(PdfName.BITSPERCOMPONENT));
                    logger.trace("pdfStream --> pdfName --> BitsPerSample...: " + pdfStream.get(PdfName.BITSPERSAMPLE));
                    logger.trace("pdfStream --> pdfName --> ColorSpace......: " + pdfStream.get(PdfName.COLORSPACE));
                    logger.trace("pdfStream --> pdfName --> CCITTFaxDecode..: " + pdfStream.get(PdfName.CCITTFAXDECODE));
                    logger.trace("pdfStream --> pdfName --> Document........: " + pdfStream.get(PdfName.DOCUMENT));
                    logger.trace("pdfStream --> pdfName --> Decode..........: " + pdfStream.get(PdfName.DECODE));
                    logger.trace("pdfStream --> pdfName --> DecodeParms.....: " + pdfStream.get(PdfName.DECODEPARMS));
                    logger.trace("pdfStream --> pdfName --> DeviceGray......: " + pdfStream.get(PdfName.DEVICEGRAY));
                    logger.trace("pdfStream --> pdfName --> DeviceCMYK......: " + pdfStream.get(PdfName.DEVICECMYK));
                    logger.trace("pdfStream --> pdfName --> DeviceRGB.......: " + pdfStream.get(PdfName.DEVICERGB));
                    logger.trace("pdfStream --> pdfName --> Filter..........: " + pdfStream.get(PdfName.FILTER));
                    logger.trace("pdfStream --> pdfName --> Filter - as name: " + pdfStream.getAsName(PdfName.FILTER));
                            
                    logger.trace("pdfStream --> pdfName --> Id..............: " + pdfStream.get(PdfName.ID));
                    logger.trace("pdfStream --> pdfName --> Image...........: " + pdfStream.get(PdfName.IMAGE));
                    logger.trace("pdfStream --> pdfName --> ImageB..........: " + pdfStream.get(PdfName.IMAGEB));
                    logger.trace("pdfStream --> pdfName --> ImageC..........: " + pdfStream.get(PdfName.IMAGEC));
                    logger.trace("pdfStream --> pdfName --> ImageI..........: " + pdfStream.get(PdfName.IMAGEI));
                    logger.trace("pdfStream --> pdfName --> Imagemask.......: " + pdfStream.get(PdfName.IMAGEMASK));
                    logger.trace("pdfStream --> pdfName --> Info............: " + pdfStream.get(PdfName.INFO));
                    logger.trace("pdfStream --> pdfName --> Name............: " + pdfStream.get(PdfName.NAME));
                    logger.trace("pdfStream --> pdfName --> Named...........: " + pdfStream.get(PdfName.NAMED));
                    logger.trace("pdfStream --> pdfName --> Named - as name.: " + pdfStream.getAsName(PdfName.NAMED));
                            
                    logger.trace("pdfStream --> pdfName --> Page............: " + pdfStream.get(PdfName.PAGE));
                    logger.trace("pdfStream --> pdfName --> PageElement.....: " + pdfStream.get(PdfName.PAGEELEMENT));
                    logger.trace("pdfStream --> pdfName --> Pdf.............: " + pdfStream.get(PdfName.PDF));
                    logger.trace("pdfStream --> pdfName --> PdfDocEncoding..: " + pdfStream.get(PdfName.PDFDOCENCODING));
                    logger.trace("pdfStream --> pdfName --> Position........: " + pdfStream.get(PdfName.POSITION));
                    logger.trace("pdfStream --> pdfName --> Producer........: " + pdfStream.get(PdfName.PRODUCER));
                    logger.trace("pdfStream --> pdfName --> Properties......: " + pdfStream.get(PdfName.PROPERTIES));
                    logger.trace("pdfStream --> pdfName --> Sect............: " + pdfStream.get(PdfName.SECT));
                    logger.trace("pdfStream --> pdfName --> SubType.........: " + pdfStream.get(PdfName.SUBTYPE));
                    logger.trace("pdfStream --> pdfName --> Supplement......: " + pdfStream.get(PdfName.SUPPLEMENT));
                    logger.trace("pdfStream --> pdfName --> Title...........: " + pdfStream.get(PdfName.TITLE));
                    */
                    // logger.trace("pdfImage --> pdfName --> : " + (pdfName.).toString());

                    // Extract the image name
                    String streamImageName = (pdfStream.get(PdfName.NAME) == null ? null
                            : pdfStream.get(PdfName.NAME).toString());
                    if (streamImageName != null && streamImageName.length() > 1
                            && streamImageName.startsWith("/")) {
                        streamImageName = streamImageName.substring(1);
                    } else {
                        streamImageName = null;
                    } // end if..else

                    String exportFileWithoutExtension = (fullExportDirectoryPath != null
                            ? fullExportDirectoryPath
                            : this.fullPDFDirectoryPath)
                            + GlobalTools.getFileNameWithoutExtension(this.fullPDFFilePath) + "_(" + "p000"
                            + "_ref" + REF_NUMBER_FORMAT.format(pdfObjectCounter)
                            + (streamImageName == null ? "_unk" : "_" + streamImageName) + ")";

                    // Test
                    FileOutputStream fileOutputStream = new FileOutputStream(
                            exportFileWithoutExtension + ".jpg");

                    /*
                     * Write given byte array to a file.
                     */
                    fileOutputStream.write(byteArrayImage);
                    fileOutputStream.flush();
                    fileOutputStream.close();
                    fileOutputStream = null;

                    /* 
                     * Check image details
                     */
                    int pdfImageBitsPerComponent = -1;
                    try {
                        if (pdfStream.get(PdfName.BITSPERCOMPONENT).isNumber()) {
                            pdfImageBitsPerComponent = new Integer(
                                    pdfStream.get(PdfName.BITSPERCOMPONENT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    int pdfImageHeight = -1;
                    try {
                        if (pdfStream.get(PdfName.HEIGHT).isNumber()) {
                            pdfImageHeight = new Integer(pdfStream.get(PdfName.HEIGHT).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    int pdfImageWidth = -1;
                    try {
                        if (pdfStream.get(PdfName.WIDTH).isNumber()) {
                            pdfImageWidth = new Integer(pdfStream.get(PdfName.WIDTH).toString()).intValue();
                        }
                    } catch (NumberFormatException ex) {
                    }

                    logger.debug("Height..........:" + pdfImageHeight);
                    logger.debug("Width...........:" + pdfImageWidth);
                    logger.debug("BitsPerComponent:" + pdfImageBitsPerComponent);

                    // or you could try making a java.awt.Image from the array:

                    if (PdfName.DEVICERGB.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.FLATEDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0 && pdfImageHeight > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(byteArrayImage,
                                pdfImageWidth, pdfImageHeight, pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } else if (PdfName.DEVICEGRAY.equals(pdfStream.get(PdfName.COLORSPACE))
                            && PdfName.RUNLENGTHDECODE.equals(pdfStream.get(PdfName.FILTER))
                            && pdfImageBitsPerComponent > 0 && pdfImageWidth > 0) {

                        BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(
                                ImageProcessingTools.runLengthDecode(byteArrayImage), pdfImageWidth, 2233,
                                pdfImageBitsPerComponent);
                        if (bufferedImage != null) {
                            ImageIO.write(bufferedImage, "PNG",
                                    new FileOutputStream(exportFileWithoutExtension + "_imageIO" + ".png"));
                        } // end if
                    } // end if...

                    /*
                    Image image = Toolkit.getDefaultToolkit().createImage(imageByteArray);
                            
                            
                    BufferedImage bufferedImage = ImageProcessingTools.toBufferedImage(image, pdfImageWidth, pdfImageHeight);
                    if (bufferedImage != null) {
                       System.out.println("Image-Height....:" + bufferedImage.getHeight());
                       System.out.println("Image-Width.....:" + bufferedImage.getWidth());
                       System.out.println("Image-isAlphaP..:" + bufferedImage.isAlphaPremultiplied());
                       File pngOutputFile = new File(exportFileWithoutExtension + "_imageIO.jpg");
                       ImageIO.write(bufferedImage, "jpg", pngOutputFile);
                    }
                    */
                    /**/

                } // end if
            } // end if 
        } // end if
    } // end for
}

---

From source file:org.opensignature.opensignpdf.PDFSigner.java

License:Open Source License

/**
 * Allow you to sign a PDF File with a PKCS11 session opened.
 * /* w  ww  . java 2s. c om*/
 * @param mySign
 * @param session
 * @param pdfFiles
 * @param suffix
 * @param reason
 * @param signatureVisibility
 * @param cal
 * @throws OpenSignatureException
 * @throws TokenException
 * @throws IOException
 * @throws CertificateException
 * @throws OpenSignatureException
 * @throws KeyStoreException
 * @throws UnrecoverableKeyException
 * @throws NoSuchAlgorithmException
 * @throws FileNotFoundException
 * @throws DocumentException
 * @throws NoSuchAlgorithmException
 * @throws ExceptionConverter
 */
public void signPDFwithKS(KeyStore ks, String alias, String pwd, File[] pdfFiles, String suffix, String reason,
        boolean signatureVisibility, Calendar cal)
        throws OpenSignatureException, KeyStoreException, NoSuchAlgorithmException, UnrecoverableKeyException {

    if (pdfFiles == null || ks == null) {
        throw new OpenSignatureException("Invalid parameters.");
    }

    // -- System's date by default 
    if (cal == null) {
        cal = Calendar.getInstance();
    }

    logger.info("[signPDFwithKS.in]:: " + Arrays.asList(new Object[] { "<ks>", alias, Arrays.asList(pdfFiles),
            suffix, reason, Boolean.valueOf(signatureVisibility) }));

    if (alias == null) {

        Enumeration aliases = ks.aliases();
        while (aliases.hasMoreElements()) {
            String alTmp = (String) aliases.nextElement();
            logger.debug("[signPDFwithKS]:: alTmp: " + alTmp);

            X509Certificate x509certificate = (X509Certificate) ks.getCertificate(alTmp);
            boolean[] keyUsage = x509certificate.getKeyUsage();
            if (keyUsage != null && (keyUsage[1] || keyUsage[0])) {
                alias = alTmp;
                break;
            }

        }
    }

    logger.debug("\n\n[signPDFwithKS]:: alias: " + alias + "\n\n");
    PrivateKey key = (PrivateKey) ks.getKey(alias, pwd.toCharArray());
    Certificate[] certs = ks.getCertificateChain(alias);

    for (int i = 0; i < pdfFiles.length; i++) {

        logger.info("[signPDFwithKS]:: Signing the file: " + pdfFiles[i].getAbsolutePath());

        try {

            // -- Check the access to the PDF
            if (!pdfFiles[i].exists() || !pdfFiles[i].canRead()) {
                throw new FileNotFoundException(
                        "The file '" + pdfFiles[i].getAbsolutePath() + "' doesn't exist.");
            }

            byte signatureBytes[] = new byte[128];

            // -- Creating the OutputStream overwritting the file if it exists
            // previously
            File fOut = FileUtils.addSuffix(pdfFiles[i], suffix, true);
            FileOutputStream fos = new FileOutputStream(fOut);
            BufferedOutputStream bos = new BufferedOutputStream(fos);

            // -- Creating the reader
            PdfReader reader = createPDFReader(pdfFiles[i]);

            PdfStamperOSP stamper;

            if ("countersigner".equals(typeSignatureSelected)) {
                stamper = PdfStamperOSP.createSignature(reader, bos, '\0', null, true);
            } else {
                stamper = PdfStamperOSP.createSignature(reader, bos, '\0');
            }

            PdfSignatureAppearanceOSP sap = stamper.getSignatureAppearance();
            sap.setCrypto(null, certs, null, PdfSignatureAppearance.WINCER_SIGNED);
            sap.setReason(reason);

            if (signatureVisibility) {
                if ("countersigner".equals(typeSignatureSelected)) {
                    sap.setCertified(0);
                    sap.setVisibleSignature(fieldName);
                } else {
                    sap.setCertified(2);
                    if (!"".equals(fieldName)) {
                        sap.setVisibleSignature(fieldName);
                    } else {
                        sap.setVisibleSignature(new com.lowagie.text.Rectangle(llx, lly, urx, ury), 1, null);
                    }
                }

            }

            sap.setExternalDigest(new byte[128], new byte[20], "RSA");

            PdfDictionary dic = new PdfDictionary();
            dic.put(PdfName.FT, PdfName.SIG);
            dic.put(PdfName.FILTER, new PdfName("Adobe.PPKLite"));
            dic.put(PdfName.SUBFILTER, new PdfName("adbe.pkcs7.detached"));
            if (cal != null) {
                dic.put(PdfName.M, new PdfDate(cal));
            } else {
                dic.put(PdfName.M, new PdfNull());
            }
            dic.put(PdfName.NAME,
                    new PdfString(PdfPKCS7.getSubjectFields((X509Certificate) certs[0]).getField("CN")));
            dic.put(PdfName.REASON, new PdfString(reason));

            sap.setCryptoDictionary(dic);

            HashMap exc = new HashMap();
            exc.put(PdfName.CONTENTS, new Integer(0x5002));
            sap.preClose(exc);

            byte[] content = IOUtils.streamToByteArray(sap.getRangeStream());
            //SHA256, alias CMSSignedDataGenerator.DIGEST_SHA256,
            //        alias NISTObjectIdentifiers.id_sha256.getId(),
            //        alias "2.16.840.1.101.3.4.2.1"
            byte[] hash = MessageDigest.getInstance("2.16.840.1.101.3.4.2.1", "BC").digest(content);

            // costruzione degli authenticated attributes
            ASN1EncodableVector signedAttributes = buildSignedAttributes(hash, cal);
            byte[] bytesForSecondHash = IOUtils.toByteArray(new DERSet(signedAttributes));

            // -- Signature generated with the private key of the KS
            Signature signature = Signature.getInstance("SHA256withRSA");
            signature.initSign(key);
            signature.update(bytesForSecondHash);
            signatureBytes = signature.sign();

            byte[] encodedPkcs7 = null;
            try {

                // Create the set of Hash algorithms
                DERConstructedSet digestAlgorithms = new DERConstructedSet();

                // Creo manualmente la sequenza di digest algos
                ASN1EncodableVector algos = new ASN1EncodableVector();
                //algos.add(new DERObjectIdentifier("1.3.14.3.2.26")); // SHA1
                //SHA-256
                algos.add(new DERObjectIdentifier("2.16.840.1.101.3.4.2.1"));
                algos.add(new DERNull());
                digestAlgorithms.addObject(new DERSequence(algos));

                // Create the contentInfo.
                ASN1EncodableVector ev = new ASN1EncodableVector();
                ev.add(new DERObjectIdentifier("1.2.840.113549.1.7.1")); // PKCS7SignedData

                DERSequence contentinfo = new DERSequence(ev);

                // Get all the certificates
                //
                ASN1EncodableVector v = new ASN1EncodableVector();
                for (int c = 0; c < certs.length; c++) {
                    ASN1InputStream tempstream = new ASN1InputStream(
                            new ByteArrayInputStream(certs[c].getEncoded()));
                    v.add(tempstream.readObject());
                }

                DERSet dercertificates = new DERSet(v);

                // Create signerinfo structure.
                //
                ASN1EncodableVector signerinfo = new ASN1EncodableVector();

                // Add the signerInfo version
                //
                signerinfo.add(new DERInteger(1));

                v = new ASN1EncodableVector();
                v.add(CertUtil.getIssuer((X509Certificate) certs[0]));
                v.add(new DERInteger(((X509Certificate) certs[0]).getSerialNumber()));
                signerinfo.add(new DERSequence(v));

                // Add the digestAlgorithm
                v = new ASN1EncodableVector();
                //v.add(new DERObjectIdentifier("1.3.14.3.2.26")); // SHA1
                //SHA-256
                v.add(new DERObjectIdentifier("1.2.840.113549.1.7.1"));
                v.add(new DERNull());
                signerinfo.add(new DERSequence(v));

                // add the authenticated attribute if present
                signerinfo.add(new DERTaggedObject(false, 0, new DERSet(signedAttributes)));

                // Add the digestEncryptionAlgorithm
                v = new ASN1EncodableVector();
                v.add(new DERObjectIdentifier("1.2.840.113549.1.1.1"));// RSA
                v.add(new DERNull());
                signerinfo.add(new DERSequence(v));

                // Add the encrypted digest
                signerinfo.add(new DEROctetString(signatureBytes));

                // Add unsigned attributes (timestamp)
                if (serverTimestamp != null && !"".equals(serverTimestamp.toString())) {
                    byte[] timestampHash = MessageDigest.getInstance("SHA-256").digest(signatureBytes);
                    ASN1EncodableVector unsignedAttributes = buildUnsignedAttributes(timestampHash,
                            serverTimestamp, usernameTimestamp, passwordTimestamp);
                    if (unsignedAttributes != null) {
                        signerinfo.add(new DERTaggedObject(false, 1, new DERSet(unsignedAttributes)));
                    }
                }

                // Finally build the body out of all the components above
                ASN1EncodableVector body = new ASN1EncodableVector();
                body.add(new DERInteger(1)); // pkcs7 version, always 1
                body.add(digestAlgorithms);
                body.add(contentinfo);
                body.add(new DERTaggedObject(false, 0, dercertificates));

                // Only allow one signerInfo
                body.add(new DERSet(new DERSequence(signerinfo)));

                // Now we have the body, wrap it in it's PKCS7Signed shell
                // and return it
                //
                ASN1EncodableVector whole = new ASN1EncodableVector();
                whole.add(new DERObjectIdentifier("1.2.840.113549.1.7.2"));// PKCS7_SIGNED_DATA
                whole.add(new DERTaggedObject(0, new DERSequence(body)));

                encodedPkcs7 = IOUtils.toByteArray(new DERSequence(whole));

            } catch (Exception e) {
                throw new ExceptionConverter(e);
            }

            PdfDictionary dic2 = new PdfDictionary();

            byte out[] = new byte[0x5000 / 2];
            System.arraycopy(encodedPkcs7, 0, out, 0, encodedPkcs7.length);

            dic2.put(PdfName.CONTENTS, new PdfString(out).setHexWriting(true));
            sap.close(dic2);

            bos.close();
            fos.close();

        } catch (Exception e) {
            logger.warn("[signPDFwithKS]:: ", e);
        }

    }

    logger.info("[signPDFwithKS.out]:: ");

}

---

From source file:org.opensignature.opensignpdf.PDFSigner.java

License:Open Source License

/**
 * @param mySign/*from w w w. j a  v a 2 s  . com*/
 * @param session
 * @param reason
 * @param signCertKeyObject
 * @param certs
 * @param stamper
 * @throws IOException
 * @throws DocumentException
 * @throws NoSuchAlgorithmException
 * @throws TokenException
 * @throws ExceptionConverter
* @throws NoSuchProviderException 
 */
private void createSignatureAppearance(MyPkcs11 mySign, Session session, String reason, Key signCertKeyObject,
        X509Certificate[] certs, PdfStamperOSP stamper, boolean signatureVisible, Calendar cal)
        throws IOException, DocumentException, NoSuchAlgorithmException, TokenException, ExceptionConverter,
        NoSuchProviderException {

    logger.info("[createSignatureAppearance.in]:: ");

    byte[] signatureBytes = new byte[128];

    PdfSignatureAppearanceOSP sap = stamper.getSignatureAppearance();

    sap.setCrypto(null, certs, null, PdfSignatureAppearance.WINCER_SIGNED);
    sap.setReason(reason);

    if (signatureVisible) {
        if ("countersigner".equals(typeSignatureSelected)) {
            sap.setCertified(0);
            sap.setVisibleSignature(fieldName);
        } else {
            sap.setCertified(0);
            if ((fieldName != null) && (!"".equals(fieldName))) {
                sap.setVisibleSignature(fieldName);
            } else {
                sap.setVisibleSignature(new com.lowagie.text.Rectangle(llx, lly, urx, ury), 1, null);
            }
        }

    }

    //aggiunta di grafico per la firma
    if ("true".equals(graphicSignSelected)) {
        sap.setSignatureGraphic(Image.getInstance(fileImgfirma));
        sap.setRender(2);
    } else {
        sap.setRender(0);
    }
    sap.setExternalDigest(new byte[128], new byte[20], "RSA");

    PdfDictionary dic = new PdfDictionary();
    dic.put(PdfName.FT, PdfName.SIG);
    dic.put(PdfName.FILTER, new PdfName("Adobe.PPKLite"));
    dic.put(PdfName.SUBFILTER, new PdfName("adbe.pkcs7.detached"));
    if (cal != null) {
        dic.put(PdfName.M, new PdfDate(cal));
    } else {
        dic.put(PdfName.M, new PdfNull());
    }
    dic.put(PdfName.NAME, new PdfString(PdfPKCS7.getSubjectFields((X509Certificate) certs[0]).getField("CN")));
    dic.put(PdfName.REASON, new PdfString(reason));

    sap.setCryptoDictionary(dic);

    HashMap exc = new HashMap();
    exc.put(PdfName.CONTENTS, new Integer(0x5002));
    sap.preClose(exc);

    byte[] content = IOUtils.streamToByteArray(sap.getRangeStream());
    byte[] hash = MessageDigest.getInstance("2.16.840.1.101.3.4.2.1", "BC").digest(content);

    // costruzione degli authenticated attributes
    ASN1EncodableVector signedAttributes = buildSignedAttributes(hash, cal);
    byte[] bytesForSecondHash = IOUtils.toByteArray(new DERSet(signedAttributes));

    byte[] secondHash = MessageDigest.getInstance("2.16.840.1.101.3.4.2.1").digest(bytesForSecondHash);

    // -- Generatting the signature
    signatureBytes = mySign.sign(session, secondHash, signCertKeyObject);

    byte[] encodedPkcs7 = null;
    try {

        // Create the set of Hash algorithms
        DERConstructedSet digestAlgorithms = new DERConstructedSet();

        // Creo manualmente la sequenza di digest algos
        ASN1EncodableVector algos = new ASN1EncodableVector();
        //algos.add(new DERObjectIdentifier("1.3.14.3.2.26")); // SHA1
        //SHA256
        algos.add(new DERObjectIdentifier("2.16.840.1.101.3.4.2.1"));
        algos.add(new DERNull());
        digestAlgorithms.addObject(new DERSequence(algos));

        // Create the contentInfo.
        ASN1EncodableVector ev = new ASN1EncodableVector();
        ev.add(new DERObjectIdentifier("1.2.840.113549.1.7.1")); // PKCS7SignedData

        DERSequence contentinfo = new DERSequence(ev);

        // Get all the certificates
        //
        ASN1EncodableVector v = new ASN1EncodableVector();
        for (int c = 0; c < certs.length; c++) {
            ASN1InputStream tempstream = new ASN1InputStream(new ByteArrayInputStream(certs[c].getEncoded()));
            v.add(tempstream.readObject());
        }

        DERSet dercertificates = new DERSet(v);

        // Create signerinfo structure.
        //
        ASN1EncodableVector signerinfo = new ASN1EncodableVector();

        // Add the signerInfo version
        //
        signerinfo.add(new DERInteger(1));

        v = new ASN1EncodableVector();
        v.add(CertUtil.getIssuer(certs[0]));
        v.add(new DERInteger(certs[0].getSerialNumber()));
        signerinfo.add(new DERSequence(v));

        // Add the digestAlgorithm
        v = new ASN1EncodableVector();
        //v.add(new DERObjectIdentifier("1.3.14.3.2.26")); // SHA1
        //SHA-256
        v.add(new DERObjectIdentifier("2.16.840.1.101.3.4.2.1"));
        v.add(new DERNull());
        signerinfo.add(new DERSequence(v));

        // add the authenticated attribute if present
        signerinfo.add(new DERTaggedObject(false, 0, new DERSet(signedAttributes)));

        // Add the digestEncryptionAlgorithm
        v = new ASN1EncodableVector();
        v.add(new DERObjectIdentifier("1.2.840.113549.1.1.1"));// RSA
        v.add(new DERNull());
        signerinfo.add(new DERSequence(v));

        // Add the encrypted digest
        signerinfo.add(new DEROctetString(signatureBytes));

        // Add unsigned attributes (timestamp)
        if (serverTimestamp != null && !"".equals(serverTimestamp.toString())) {
            byte[] timestampHash = MessageDigest.getInstance("2.16.840.1.101.3.4.2.1", "BC")
                    .digest(signatureBytes);
            ASN1EncodableVector unsignedAttributes = buildUnsignedAttributes(timestampHash, serverTimestamp,
                    usernameTimestamp, passwordTimestamp);
            if (unsignedAttributes != null) {
                signerinfo.add(new DERTaggedObject(false, 1, new DERSet(unsignedAttributes)));
            }
        }

        // Finally build the body out of all the components above
        ASN1EncodableVector body = new ASN1EncodableVector();
        body.add(new DERInteger(1)); // pkcs7 version, always 1
        body.add(digestAlgorithms);
        body.add(contentinfo);
        body.add(new DERTaggedObject(false, 0, dercertificates));

        // Only allow one signerInfo
        body.add(new DERSet(new DERSequence(signerinfo)));

        // Now we have the body, wrap it in it's PKCS7Signed shell
        // and return it
        //
        ASN1EncodableVector whole = new ASN1EncodableVector();
        whole.add(new DERObjectIdentifier("1.2.840.113549.1.7.2"));// PKCS7_SIGNED_DATA
        whole.add(new DERTaggedObject(0, new DERSequence(body)));

        encodedPkcs7 = IOUtils.toByteArray(new DERSequence(whole));

    } catch (Exception e) {
        throw new ExceptionConverter(e);
    }

    PdfDictionary dic2 = new PdfDictionary();

    byte out[] = new byte[0x5000 / 2];
    System.arraycopy(encodedPkcs7, 0, out, 0, encodedPkcs7.length);

    dic2.put(PdfName.CONTENTS, new PdfString(out).setHexWriting(true));
    sap.close(dic2);

    logger.info("[createSignatureAppearance.retorna]:: ");

}

---