From 6025b6016517c6d898d8957d1d7e03ba71431912 Mon Sep 17 00:00:00 2001 From: tknall Date: Fri, 1 Dec 2006 12:20:24 +0000 Subject: Initial import of release 2.2. git-svn-id: https://joinup.ec.europa.eu/svn/pdf-as/trunk@4 7b5415b0-85f9-ee4d-85bd-d5d0c3b42d1c --- .../java/at/knowcenter/wag/egov/egiz/PdfAS.java | 1083 ++++++++++++++++++++ 1 file changed, 1083 insertions(+) create mode 100644 src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java (limited to 'src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java') diff --git a/src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java b/src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java new file mode 100644 index 0000000..53fafe2 --- /dev/null +++ b/src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java @@ -0,0 +1,1083 @@ +/** + * Copyright (c) 2006 by Know-Center, Graz, Austria + * + * This software is the confidential and proprietary information of Know-Center, + * Graz, Austria. You shall not disclose such Confidential Information and shall + * use it only in accordance with the terms of the license agreement you entered + * into with Know-Center. + * + * KNOW-CENTER MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF + * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE + * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR + * NON-INFRINGEMENT. KNOW-CENTER SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY + * LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS + * DERIVATIVES. + * + * $Id: PdfAS.java,v 1.5 2006/10/31 08:04:50 wprinz Exp $ + */ +package at.knowcenter.wag.egov.egiz; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Vector; + +import org.apache.log4j.Logger; + +import at.knowcenter.wag.egov.egiz.cfg.ConfigLogger; +import at.knowcenter.wag.egov.egiz.cfg.SettingsReader; +import at.knowcenter.wag.egov.egiz.exceptions.ConnectorFactoryException; +import at.knowcenter.wag.egov.egiz.exceptions.NormalizeException; +import at.knowcenter.wag.egov.egiz.exceptions.PDFDocumentException; +import at.knowcenter.wag.egov.egiz.exceptions.PresentableException; +import at.knowcenter.wag.egov.egiz.exceptions.SettingsException; +import at.knowcenter.wag.egov.egiz.exceptions.SignatureException; +import at.knowcenter.wag.egov.egiz.exceptions.SignatureTypesException; +import at.knowcenter.wag.egov.egiz.framework.FoundBlock; +import at.knowcenter.wag.egov.egiz.framework.FoundKey; +import at.knowcenter.wag.egov.egiz.framework.SignResult; +import at.knowcenter.wag.egov.egiz.framework.Signator; +import at.knowcenter.wag.egov.egiz.framework.SignatorFactory; +import at.knowcenter.wag.egov.egiz.framework.VerificationFilter; +import at.knowcenter.wag.egov.egiz.pdf.IncrementalUpdateInformation; +import at.knowcenter.wag.egov.egiz.pdf.PDFSignatureCreation; +import at.knowcenter.wag.egov.egiz.pdf.PDFSignatureObject; +import at.knowcenter.wag.egov.egiz.pdf.PDFUtilities; +import at.knowcenter.wag.egov.egiz.pdf.SignatureHolder; +import at.knowcenter.wag.egov.egiz.pdf.TextualSignatureHolder; +import at.knowcenter.wag.egov.egiz.pdf.TablePos; +import at.knowcenter.wag.egov.egiz.pdf.TextualSignature; +import at.knowcenter.wag.egov.egiz.sig.Connector; +import at.knowcenter.wag.egov.egiz.sig.ConnectorFactory; +import at.knowcenter.wag.egov.egiz.sig.SignatureObject; +import at.knowcenter.wag.egov.egiz.sig.SignatureResponse; +import at.knowcenter.wag.egov.egiz.sig.SignatureTypeDefinition; +import at.knowcenter.wag.egov.egiz.sig.SignatureTypes; +import at.knowcenter.wag.egov.egiz.tools.Normalizer; +import at.knowcenter.wag.exactparser.parsing.PDFUtils; +import at.knowcenter.wag.exactparser.parsing.results.HeaderParseResult; + +import com.lowagie.text.Rectangle; +import com.lowagie.text.pdf.PdfPTable; +import com.lowagie.text.pdf.PdfReader; + +/** + * This class contains the major methods used by both, the commandline and the + * webapp, to perform signation and verification. + * + * @author wprinz + */ +public abstract class PdfAS +{ + /** + * The key of the strict mode setting. + */ + public static final String STRICT_MODE_KEY = "strict_mode"; + + /** + * The left/right border. + */ + public static final float SIGNATURE_BORDER = 100f; + + /** + * The top/bottom border. + */ + public static final float SIGNATURE_MARGIN = 20f; + + /** + * The Mime Type of a PDF document. + */ + public static final String PDF_MIME_TYPE = "application/pdf"; + + /** + * The logger definition. + */ + private static final Logger logger_ = ConfigLogger.getLogger(PdfAS.class); + + /** + * Tells, if strict PDF checking the PDF version is enabled. + * + * @return Returns true, if incoming PDFs should be checked strictly. + */ + public static boolean isStrictPdfChecking() + { + try + { + SettingsReader settings = SettingsReader.getInstance(); + String strict_mode = settings.getSetting(STRICT_MODE_KEY, "false"); + if (strict_mode.equals("true")) + { + return true; + } + } + catch (SettingsException e) + { + e.printStackTrace(); + } + return false; + } + + /** + * Checks the version of the given PDF to be 1.4 or lower. + * + * @param pdf + * The PDF. + * @return Returns true, if the given PDF is strict 1.4, false otherwise. + * @throws PDFDocumentException + * Forwarded exception. + */ + public static boolean isPdf14(byte[] pdf) throws PDFDocumentException + { + try + { + HeaderParseResult hpr = PDFUtils.parseHeader(pdf, 0); + + if (hpr.major <= 1 && hpr.minor <= 4) + { + return true; + } + return false; + } + catch (Exception e) + { + throw new PDFDocumentException(201, e); + } + } + + /** + * Applies strict version mode on the PDF and throws an exception, if the pdf + * is not 1.4. + * + *

+ * If strict mode is deactivated, this does simply nothing. + *

+ * + * @param pdf + * The pdf to be checked against strict mode. + * @throws PDFDocumentException + */ + public static void applyStrictMode(byte[] pdf) throws PDFDocumentException + { + if (isStrictPdfChecking()) + { + if (!isPdf14(pdf)) + { + throw new PDFDocumentException(201, "StrictMode: The pdf version is not 1.4 or lower."); + } + } + } + + /** + * Verifies the given PDF document. + * + * @param pdf + * The PDF document. + * @param connector + * The connector. + * @return Returns the List of results. + * @throws PresentableException + * Forwarded exception. + */ + public static List verifyPdf(final byte[] pdf, final String connector) throws PresentableException + { + VerificationFilter vf = new VerificationFilter(); + List signature_holders = vf.extractSignaturesFromPdf(pdf); + if (signature_holders.isEmpty()) + { + throw new PDFDocumentException(206); + } + + List results = verifySignatureHolders(signature_holders, connector); + + return results; + } + + /** + * Verifies the given text that is supposed to be extracted from a PDF + * document using text extraction mechanisms. + * + * @param text + * The text to be verified. + * @param connector + * The connecor. + * @return Returns the List of results. + * @throws PresentableException + * Forwarded exception. + */ + public static List verifyText(final String text, final String connector) throws PresentableException + { + VerificationFilter vf = new VerificationFilter(); + List signature_holders = vf.extractSignaturesFromPlainText(text); + if (signature_holders.isEmpty()) + { + throw new PDFDocumentException(206); + } + + List results = verifySignatureHolders(signature_holders, connector); + + return results; + } + + /** + * Extracts all signature blocks from the given raw text using textual mode. + * + * @param raw_text + * The raw text. + * @return Returns a List of all SignatureHolders extracted from the text. + * @throws PDFDocumentException + * F.e. + * @throws SignatureException + * F.e. + * @throws SignatureTypesException + * @throws NormalizeException + */ + public static List extractSignatureHoldersTextual(String raw_text, + boolean old_style) throws PDFDocumentException, SignatureException, SignatureTypesException, NormalizeException + { + List signature_holders = new ArrayList(); + + String text = raw_text; + for (;;) + { + SignatureHolder holder = extractSignatureHolderTextual(text, old_style); + if (holder == null) + { + break; + } + { + logger_.debug("Found holder: " + holder.getSignatureObject().getSignationType()); + } + signature_holders.add(0, holder); + + text = holder.getSignedText(); + } + + return signature_holders; + } + + /** + * Extracts the last signature holder from the given text. + * + * @param raw_text + * @param old_style + * @return Returns the found singature holder, or null, if none could be + * found. + * @throws SignatureException + * @throws SignatureTypesException + * @throws NormalizeException + */ + public static SignatureHolder extractSignatureHolderTextual(String raw_text, + boolean old_style) throws SignatureException, SignatureTypesException, NormalizeException + { + SignatureTypes sig_types = SignatureTypes.getInstance(); + List signatureTypes_ = sig_types.getSignatureTypeDefinitions(); + + List found_blocks = new ArrayList(); + for (int cur_type = 0; cur_type < signatureTypes_.size(); cur_type++) + { + SignatureTypeDefinition cur_std = (SignatureTypeDefinition) signatureTypes_.get(cur_type); + + List found_keys = findBlockInText(raw_text, cur_std, old_style); + if (found_keys != null) + { + FoundBlock found_block = new FoundBlock(); + found_block.found_keys = found_keys; + found_block.end_index = raw_text.length(); + found_block.std = cur_std; + found_blocks.add(found_block); + } + } + + List last_most_blocks = sortOutEarlyBlocks(found_blocks); + + List minimum_blocks = sortOutLargeBlocks(last_most_blocks); + + if (minimum_blocks.size() > 1) + { + logger_.debug("There are still " + minimum_blocks.size() + " candidates:"); + + for (int i = 0; i < minimum_blocks.size(); i++) + { + FoundBlock fb = (FoundBlock) minimum_blocks.get(i); + logger_.debug(" fb: " + fb.std.getType()); + } + + logger_.debug("... checking for Semantic Equality."); + } + + boolean semantic_equality = checkForSemanticEquality(minimum_blocks); + + if (minimum_blocks.size() > 1) + { + logger_.debug("... Semantic Equality = " + semantic_equality); + } + + if (!semantic_equality) + { + throw new SignatureException(314); + } + + if (!minimum_blocks.isEmpty()) + { + FoundBlock actual_block = (FoundBlock) minimum_blocks.get(0); + + String signed_text = raw_text.substring(0, actual_block.getFirstKey().start_index); + + SignatureObject signatureObject_ = new SignatureObject(); + signatureObject_.setSigType(actual_block.std.getType()); + signatureObject_.initByType(); + + int end_index = actual_block.end_index; + for (int i = 0; i < actual_block.found_keys.size(); i++) + { + FoundKey cur_key = (FoundKey) actual_block.found_keys.get(i); + int start_index = cur_key.getStartIndex() + cur_key.caption.length(); + + String value = raw_text.substring(start_index, end_index); + + signatureObject_.setSigValueCaption(cur_key.getKey(), value, cur_key.caption); + + end_index = cur_key.getStartIndex(); + } + + // this normalization is required to get rid of possible trailing newlines. + String normalized_text = normalizeText(signed_text); + SignatureHolder holder = new TextualSignatureHolder(normalized_text, signatureObject_); + return holder; + } + + return null; + } + + /** + * Tries to find a block of the given type in the text. + * + * @param text + * The text. + * @param sig_type_def + * The type of the block. + * @param old_style + * Tells, if the block is old style (SIG_KZ will be ignored), or if + * it is a new block. + * @return Returns a List of the found keys of the block, or null, if the + * block could not be found. + */ + public static List findBlockInText(String text, + SignatureTypeDefinition sig_type_def, boolean old_style) + { + Vector keys = sig_type_def.getRevertSortedKeys(); + Vector captions = sig_type_def.getRevertSortedCaptions(); + + int last_index = text.length(); + + List found_keys = new ArrayList(); + for (int key_idx = 0; key_idx < keys.size(); key_idx++) + { + String key = (String) keys.get(key_idx); + + if (old_style && key.equals(SignatureTypes.SIG_KZ)) + { + // If separating the old style way - skip The "Kennzeichnung" + // key, because it wasn't present in old profiles. + continue; + } + + String caption = (String) captions.get(key_idx); + + int found_index = text.lastIndexOf(caption); + + if (key.equals(SignatureTypes.SIG_ID)) + { + if (found_index < 0 || found_index >= last_index) + { + // not found, SIG_ID is not required + continue; + } + FoundKey fk = new FoundKey(key, caption, found_index); + found_keys.add(fk); + } + else + { + if (found_index < 0 || found_index >= last_index) + { + // one key is not found - the profile doesn't match. + return null; + } + + FoundKey fk = new FoundKey(key, caption, found_index); + found_keys.add(fk); + last_index = found_index; + } + } + + sortFoundKeysDescendingly(found_keys); + + boolean matched = checkThatOrderIsCorrectAndCorrectFoundKeys(found_keys, keys, old_style); + // boolean found_required = checkFoundRequiredKeys(found_keys, old_style); + + if (matched) + { + return found_keys; + } + return null; + } + + /** + * Sorts the FoundKeys List descendingly according to the start indices of the + * found keys (the first found key in the list will have the highest start + * index, the second one the second highest and so forth). + * + * @param found_keys + * The List of FoundKey objects to be sorted. + */ + public static void sortFoundKeysDescendingly(List found_keys) + { + // sort the found_keys according to their start pos reversely. + + Collections.sort(found_keys, new Comparator() + { + public int compare(Object arg0, Object arg1) + { + FoundKey fk0 = (FoundKey) arg0; + FoundKey fk1 = (FoundKey) arg1; + // sort reversely! + return fk1.start_index - fk0.start_index; + } + }); + } + + /** + * Sorts the FoundKeys List ascendingly according to the start indices of the + * found keys (the first found key in the list will have the lowest start + * index, the second one the second lowest and so forth). + * + * @param found_keys + * The List of FoundKey objects to be sorted. + */ + public static void sortFoundKeysAscendingly(List found_keys) + { + // sort the found_keys according to their start pos. + + Collections.sort(found_keys, new Comparator() + { + public int compare(Object arg0, Object arg1) + { + FoundKey fk0 = (FoundKey) arg0; + FoundKey fk1 = (FoundKey) arg1; + return fk0.start_index - fk1.start_index; + } + }); + } + + /** + * Checks that the found keys are in correct order regarding SIG_ID as + * optional key. + * + *

+ * If the SIG_ID key is misplaced, it will be removed from the found keys + * list. + *

+ * + * @param found_keys + * The found keys ordered descendingly to their start position + * @param profile_keys + * The profile keys. + * @param old_style + * Tells, if SIG_KZ should be ignored, or not. + * @return Returns true, if the keys are correct. + */ + public static boolean checkThatOrderIsCorrectAndCorrectFoundKeys( + List found_keys, List profile_keys, boolean old_style) + { + + int found_index = 0; + for (int profile_index = 0; profile_index < profile_keys.size(); profile_index++) + { + String key = (String) profile_keys.get(profile_index); + + if (old_style && key.equals(SignatureTypes.SIG_KZ)) + { + continue; + } + + FoundKey found_key = (FoundKey) found_keys.get(found_index); + + boolean match = key.equals(found_key.getKey()); + if (match) + { + found_index++; + continue; + } + + if (key.equals(SignatureTypes.SIG_ID)) + { + continue; + } + + // doesn't match + return false; + } + + // remove all fields above the found_index - they are not correctly matched + // indices (should be only the ID + int size = found_keys.size(); + for (int i = found_index; i < size; i++) + { + // this removes all (size - found_index) objects above found_index + found_keys.remove(found_index); + } + + return true; + } + + /** + * Sorts out early blocks and leaves only those at the bottom of the text. + * + * @param found_blocks + * The found blocks. + * @return Returns a list of the last blocks. + */ + public static List sortOutEarlyBlocks(List found_blocks) + { + int last_most_index = Integer.MIN_VALUE; + + List last_most_blocks = new ArrayList(); + for (int block_index = 0; block_index < found_blocks.size(); block_index++) + { + FoundBlock block = (FoundBlock) found_blocks.get(block_index); + + int this_last_index = block.getLastKey().start_index; + if (this_last_index < last_most_index) + { + // this block cannot be the last most block. + continue; + } + if (this_last_index == last_most_index) + { + last_most_blocks.add(block); + continue; + } + if (this_last_index > last_most_index) + { + last_most_blocks = new ArrayList(); + last_most_blocks.add(block); + last_most_index = this_last_index; + } + } + + return last_most_blocks; + } + + /** + * Sorts out large blocks. + * + * @param found_blocks + * The found blocks. + * @return Returns a list of the smallest blocks. + */ + public static List sortOutLargeBlocks(List found_blocks) + { + int last_min_size = Integer.MAX_VALUE; + + List min_size_blocks = new ArrayList(); + for (int block_index = 0; block_index < found_blocks.size(); block_index++) + { + FoundBlock block = (FoundBlock) found_blocks.get(block_index); + + int size = block.getSize(); + + if (size > last_min_size) + { + // this block is larger + continue; + } + if (size == last_min_size) + { + min_size_blocks.add(block); + continue; + } + if (size < last_min_size) + { + min_size_blocks = new ArrayList(); + min_size_blocks.add(block); + last_min_size = size; + } + } + + return min_size_blocks; + } + + /** + * Checks the list of blocks for semantic equality. + * + * @param found_blocks + * The list of found blocks. + * @return Returns true if all blocks are semantically equal. + */ + public static boolean checkForSemanticEquality(List found_blocks) + { + if (found_blocks.size() <= 1) + { + return true; + } + + for (int block_index = 0; block_index < found_blocks.size() - 1; block_index++) + { + FoundBlock first_block = (FoundBlock) found_blocks.get(block_index); + FoundBlock second_block = (FoundBlock) found_blocks.get(block_index + 1); + + if (!first_block.isSemanticallyEqual(second_block)) + { + return false; + } + } + + return true; + } + + public static int getIndexOfFoundKey(List found_keys, String key) + { + for (int i = 0; i < found_keys.size(); i++) + { + FoundKey fk = (FoundKey) found_keys.get(i); + if (fk.getKey().equals(key)) + { + return i; + } + } + return -1; + } + + public static boolean containsFoundKey(List found_keys, String key) + { + return getIndexOfFoundKey(found_keys, key) >= 0; + } + + /** + * Checks the found keys for the required keys regarding the old style. + * + * @param found_keys + * The found keys. + * @param old_style + * Flag that tells, if KZ is not required. + * @return Returns true, if all required keys were found. + */ + public static boolean checkFoundRequiredKeys(List found_keys, + boolean old_style) + { + if (!containsFoundKey(found_keys, SignatureTypes.SIG_DATE)) + { + return false; + } + if (!containsFoundKey(found_keys, SignatureTypes.SIG_ISSUER)) + { + return false; + } + if (!containsFoundKey(found_keys, SignatureTypes.SIG_NUMBER)) + { + return false; + } + if (!containsFoundKey(found_keys, SignatureTypes.SIG_VALUE)) + { + return false; + } + if (!old_style && !containsFoundKey(found_keys, SignatureTypes.SIG_KZ)) + { + return false; + } + return true; + } + + /** + * Verifies the List of SignatureHolders using the given connector. + * + * @param signature_holders + * The List of SignatureHolder objects to be verified. + * @param connector + * The connector. + * @return Returns the List of SignatureResponse objects. + * @throws PDFDocumentException + * F.e. + * @throws NormalizeException + * F.e. + * @throws SignatureException + * F.e. + */ + public static List verifySignatureHolders(List signature_holders, + String connector) throws PDFDocumentException, NormalizeException, SignatureException + { + List results = new ArrayList(); + for (int i = 0; i < signature_holders.size(); i++) + { + SignatureHolder holder = (SignatureHolder) signature_holders.get(i); + + // logger_.debug(); + // logger_.debug(); + // logger_.debug("Verifying Holder " + i + "..."); + // logger_.debug("holder[" + i + "].signed_text = " + + // holder.signed_text); + // logger_.debug("holder[" + i + "].sig_obj = "); + // logger_.debug("holder[" + i + "].type = " + + // (holder.signature_object.isTextual() ? "textual" : "binary")); + // logger_.debug(holder.signature_object.toString()); + + SignatureResponse result = verify(holder, connector); + results.add(result); + + // logger_.debug(); + // logger_.debug("check[" + i + "].cert = " + + // result.getCertificateCheckInfo()); + // logger_.debug("check[" + i + "].sig = " + + // result.getSignatureCheckInfo().trim()); + // logger_.debug("check[" + i + "].manifest = " + + // result.getSignatureManifestCheckInfo()); + // logger_.debug(); + } + return results; + } + + /** + * Verifies a SignatureHolder using the given connector. + * + * @param signature_holder + * The SignatureHolder to be verified. + * @param connector + * The connector. + * @return Returns the SignatureResponse object. + * @throws NormalizeException + * F.e. + * @throws PDFDocumentException + * F.e. + * @throws SignatureException + * F.e. + */ + public static SignatureResponse verify(SignatureHolder signature_holder, + String connector) throws NormalizeException, PDFDocumentException, SignatureException + { + String text_to_be_verified = signature_holder.getSignedText(); + + SignatureObject so_to_be_verified = signature_holder.getSignatureObject(); + + if (text_to_be_verified == null) + { + throw new SignatureException(311, "Document can not be verified because the text to be verified is either null."); + } + if (text_to_be_verified.length() <= 0) + { + throw new SignatureException(311, "Document can not be verified because the length of the text to be verified is 0. (length = " + text_to_be_verified.length() + ")"); + } + + if (so_to_be_verified == null) + { + throw new SignatureException(312, "Document can not be verified because no signature object are set."); + } + + try + { + Connector connector_impl = ConnectorFactory.createConnector(connector); + return connector_impl.doVerify(text_to_be_verified, so_to_be_verified); + } + catch (ConnectorFactoryException e) + { + throw new SignatureException(310, e); + } + } + + /** + * Signs the given text with the provided connector using the given signature + * type. + * + * @param text_to_sign + * The text String to be signed. + * @param signature_type + * The type of the signature. + * @param connector + * The connector. + * @param user_name + * The user name. + * @param user_password + * The user password. + * @return Returns the corresponding SignatureObject. + * @throws SignatureException + * F.e. + * @throws PDFDocumentException + * F.e. + */ + public static SignatureObject sign(final String text_to_sign, + final String signature_type, final String connector, + final String user_name, final String user_password) throws SignatureException, PDFDocumentException + { + logger_.info("User signed a document: " + user_name); + + if (text_to_sign == null) { + throw new SignatureException(301, "Signature can not be produced. Text is null."); + } + if (text_to_sign.length() <= 0) + { + throw new SignatureException(301, "Signature can not be produced. Text is empty. (length = " + text_to_sign.length() + ")"); + } + + try + { + Connector connector_impl = ConnectorFactory.createConnector(connector); + SignatureObject signed_signature_object = connector_impl.doSign(signature_type, user_name, text_to_sign); + return signed_signature_object; + } + catch (ConnectorFactoryException e) + { + throw new SignatureException(300, e); + } + } + + /** + * Helper method that creates a SignatureObject and initializes it with the + * given type. + * + * @param signature_type + * The type. + * @return Returns the created SignatureObject. + * @throws SignatureException + * f.e. + * @throws SignatureTypesException + * f.e. + */ + public static SignatureObject createSignatureObjectFromType( + final String signature_type) throws SignatureException, SignatureTypesException + { + SignatureObject sig_obj = new SignatureObject(); + sig_obj.setSigType(signature_type); + sig_obj.initByType(); + + return sig_obj; + } + + /** + * Signs the document using the given algorithm. + * + * @param algorithm + * The Signator algorithm to be used. + * @param pdf + * The PDF. + * @param signature_type + * The signature type. + * @param connector + * The connector. + * @param user_name + * The user name. + * @param user_password + * The password. + * @param pos + * The absolute position. If null, the position is either taken from + * the profile or computed automatically. + * @return Returns the SignResult. + * @throws PresentableException + * F.e. + */ + public static SignResult sign(PdfASID algorithm, final byte[] pdf, + final String signature_type, final String connector, + final String user_name, final String user_password, TablePos pos) throws PresentableException + { + Signator signator = SignatorFactory.createSignator(algorithm); + + IncrementalUpdateInformation iui = signator.prepareSign(pdf, signature_type, pos, ConnectorFactory.needsSIG_ID(connector)); + + iui.signed_signature_object = sign(iui.document_text, signature_type, connector, user_name, user_password); + + SignResult sign_result = signator.finishSign(iui); + + return sign_result; + } + + /** + * Extracts and normalizes the text from the pdf. + * + * @param pdf + * The PDF document. + * @return Returns the text String. + * @throws PresentableException + * F.e. + */ + public static String extractNormalizedTextTextual(final byte[] pdf) throws PresentableException + { +// ByteArrayInputStream bais = new ByteArrayInputStream(pdf); +// String raw_document_text = TextualSignature.extractTextTextual(bais); +// +// String document_text = normalizeText(raw_document_text); + + return extractNormalizedTextTextual(pdf, pdf.length); + } + + /** + * Extracts and normalizes the text from the pdf. + * + * @param pdf + * The PDF document. + * @param length + * The length of the PDF document. The decument is considered to be + * that long even if the byte array is longer. + * @return Returns the text String. + * @throws PresentableException + * F.e. + */ + public static String extractNormalizedTextTextual(final byte[] pdf, final int length) throws PresentableException + { + ByteArrayInputStream bais = new ByteArrayInputStream(pdf, 0, length); + String raw_document_text = TextualSignature.extractTextTextual(bais); + + String document_text = normalizeText(raw_document_text); + + return document_text; + } + + /** + * Normalizes the given text. + * + * @param text + * The text to be normalized. + * @return Returns the normalized text. + * @throws NormalizeException + * F.e. + */ + public static String normalizeText(final String text) throws NormalizeException + { + Normalizer normalizer = new Normalizer(); + String normalized_text = normalizer.normalize(text); + return normalized_text; + } + + /** + * Creates the iText PDFPTable from a given SignatureObject. + * + * @param signature_object + * The SignatureObject. + * @return Returns the created PDFPTable. + * @throws PDFDocumentException + * F.e. + * @throws SignatureException + * F.e. + */ + public static PdfPTable createPdfPTableFromSignatureObject( + final SignatureObject signature_object) throws PDFDocumentException, SignatureException + { + PDFSignatureCreation creation = new PDFSignatureCreation(signature_object); + PDFSignatureObject pdf_sig_obj = creation.getPDFSignatureObject(); + PdfPTable pdf_table = (PdfPTable) pdf_sig_obj.getSignatureObject(); + + return pdf_table; + } + + /** + * Sets the width of the table according to the layout of the document and + * calculates the y position where the PDFPTable should be placed. + * + * @param pdf + * The PDF document. + * @param pdf_table + * The PDFPTable to be placed. + * @return Returns the position where the PDFPTable should be placed. + * @throws PDFDocumentException + * F.e. + */ + public static TablePos adjustTableAndCalculatePosition(final byte[] pdf, + PdfPTable pdf_table) throws PDFDocumentException + { + TablePos pos = new TablePos(); + + PdfReader reader = readInPdfDocument(pdf); + + Rectangle psize = reader.getPageSizeWithRotation(reader.getNumberOfPages()); + float page_width = psize.width(); + float page_height = psize.height(); + + pos.width = page_width - SIGNATURE_BORDER; + pdf_table.setTotalWidth(pos.width); + pdf_table.setLockedWidth(true); + + pos.pos_x = SIGNATURE_BORDER / 2; + + float table_height = pdf_table.getTotalHeight(); + float page_length = PDFUtilities.calculateLastPageLength(pdf); + pos.pos_y = page_height - page_length - SIGNATURE_MARGIN; + + pos.page = reader.getNumberOfPages(); + if (pos.pos_y <= table_height) + { + pos.page = -1; + // negative means to add a new page + pos.pos_y = page_height - SIGNATURE_BORDER / 2; + } + + return pos; + } + + /** + * Creates an iText Reader that parses the document. + *

+ * This is a convenience function for wrapping the Reader's exceptions into + * PDFDocumentException. + *

+ * + * @param pdf + * The PDF document. + * @return Returns the created PdfReader. + * @throws PDFDocumentException + * F.e. + */ + public static PdfReader readInPdfDocument(final byte[] pdf) throws PDFDocumentException + { + try + { + return new PdfReader(pdf); + } + catch (IOException e) + { + throw new PDFDocumentException(201, e); + } + } + + /** + * Parses the TablePos object from a given String with the appropriate format. + * + * @param pos_string + * The pos string. e.g. 1;40.0;600.0;300.0 + * @return Returns the parsed TablePos object. + * @throws PDFDocumentException + * Thrown, if the String doesn't have the proper format. + */ + public static TablePos parsePositionFromPosString(String pos_string) throws PDFDocumentException + { + String[] strs = pos_string.split(";"); + if (strs.length != 4) + { + throw new PDFDocumentException(224, "Pos string (=" + pos_string + ") is invalid."); + } + + try + { + TablePos pos = new TablePos(); + pos.page = Integer.parseInt(strs[0]); + pos.pos_x = Float.parseFloat(strs[1]); + pos.pos_y = Float.parseFloat(strs[2]); + pos.width = Float.parseFloat(strs[3]); + + if (pos.page < 1 && pos.page != -1) + { + throw new PDFDocumentException(225, "pos.page (=" + pos.page + ") must not be lower than -1 and must not be 0."); + } + + if (pos.width <= 0.0f) + { + throw new PDFDocumentException(226, "pos.width (=" + pos.width + ") must not be lower or equal 0."); + } + + return pos; + } + catch (NumberFormatException e) + { + throw new PDFDocumentException(224, "Pos string (=" + pos_string + ") cannot be parsed."); + } + } +} -- cgit v1.2.3