diff options
Diffstat (limited to 'src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java')
| -rw-r--r-- | src/main/java/at/knowcenter/wag/egov/egiz/PdfAS.java | 1083 |
1 files changed, 1083 insertions, 0 deletions
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> Copyright (c) 2006 by Know-Center, Graz, Austria </copyright>
+ *
+ * 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.
+ *
+ * <p>
+ * If strict mode is deactivated, this does simply nothing.
+ * </p>
+ *
+ * @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.
+ *
+ * <p>
+ * If the SIG_ID key is misplaced, it will be removed from the found keys
+ * list.
+ * </p>
+ *
+ * @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.
+ * <p>
+ * This is a convenience function for wrapping the Reader's exceptions into
+ * PDFDocumentException.
+ * </p>
+ *
+ * @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.");
+ }
+ }
+}
|