diff options
Diffstat (limited to 'pdf-as-lib/src/main/java/at/gv/egiz/pdfas/commandline/Main.java')
| -rw-r--r-- | pdf-as-lib/src/main/java/at/gv/egiz/pdfas/commandline/Main.java | 1275 |
1 files changed, 1275 insertions, 0 deletions
diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/pdfas/commandline/Main.java b/pdf-as-lib/src/main/java/at/gv/egiz/pdfas/commandline/Main.java new file mode 100644 index 0000000..52355f8 --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/pdfas/commandline/Main.java @@ -0,0 +1,1275 @@ +/**
+ * <copyright> Copyright 2006 by Know-Center, Graz, Austria </copyright>
+ * PDF-AS has been contracted by the E-Government Innovation Center EGIZ, a
+ * joint initiative of the Federal Chancellery Austria and Graz University of
+ * Technology.
+ *
+ * Licensed under the EUPL, Version 1.1 or - as soon they will be approved by
+ * the European Commission - subsequent versions of the EUPL (the "Licence");
+ * You may not use this work except in compliance with the Licence.
+ * You may obtain a copy of the Licence at:
+ * http://www.osor.eu/eupl/
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the Licence is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the Licence for the specific language governing permissions and
+ * limitations under the Licence.
+ *
+ * This product combines work with different licenses. See the "NOTICE" text
+ * file for details on the various modules and licenses.
+ * The "NOTICE" text file is part of the distribution. Any derivative works
+ * that you distribute must include a readable copy of the "NOTICE" text file.
+ *
+ * $Id: Main.java,v 1.5 2006/10/31 08:06:56 wprinz Exp $
+ */
+package at.gv.egiz.pdfas.commandline;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import at.gv.egiz.pdfas.PdfAsFactory;
+import at.gv.egiz.pdfas.api.PdfAs;
+import at.gv.egiz.pdfas.api.commons.Constants;
+import at.gv.egiz.pdfas.api.exceptions.ConfigUtilsException;
+import at.gv.egiz.pdfas.api.exceptions.PdfAsException;
+import at.gv.egiz.pdfas.api.io.DataSink;
+import at.gv.egiz.pdfas.api.io.DataSource;
+import at.gv.egiz.pdfas.api.sign.SignParameters;
+import at.gv.egiz.pdfas.api.sign.pos.SignaturePositioning;
+import at.gv.egiz.pdfas.api.sign.pos.axis.AbsoluteAxisAlgorithm;
+import at.gv.egiz.pdfas.api.sign.pos.page.AbsolutePageAlgorithm;
+import at.gv.egiz.pdfas.api.sign.pos.page.NewPageAlgorithm;
+import at.gv.egiz.pdfas.api.verify.VerifyParameters;
+import at.gv.egiz.pdfas.api.verify.VerifyResult;
+import at.gv.egiz.pdfas.api.verify.VerifyResults;
+import at.gv.egiz.pdfas.exceptions.ErrorCode;
+import at.gv.egiz.pdfas.exceptions.ErrorCodeHelper;
+import at.gv.egiz.pdfas.framework.config.SettingsHelper;
+import at.gv.egiz.pdfas.framework.vfilter.VerificationFilterParameters;
+import at.gv.egiz.pdfas.io.FileBasedDataSink;
+import at.gv.egiz.pdfas.io.FileBasedDataSource;
+import at.gv.egiz.pdfas.io.StringTextBasedDataSource;
+import at.gv.egiz.pdfas.utils.ConfigUtils;
+import at.knowcenter.wag.egov.egiz.PdfAS;
+import at.knowcenter.wag.egov.egiz.PdfASID;
+import at.knowcenter.wag.egov.egiz.cfg.SettingsReader;
+import at.knowcenter.wag.egov.egiz.exceptions.ConnectorFactoryException;
+import at.knowcenter.wag.egov.egiz.exceptions.PDFDocumentException;
+import at.knowcenter.wag.egov.egiz.exceptions.PresentableException;
+import at.knowcenter.wag.egov.egiz.exceptions.SettingNotFoundException;
+import at.knowcenter.wag.egov.egiz.exceptions.SignatureTypesException;
+import at.knowcenter.wag.egov.egiz.framework.SignatorFactory;
+import at.knowcenter.wag.egov.egiz.pdf.TablePos;
+import at.knowcenter.wag.egov.egiz.sig.ConnectorFactory;
+import at.knowcenter.wag.egov.egiz.sig.ConnectorInformation;
+import at.knowcenter.wag.egov.egiz.sig.SignatureTypes;
+
+/**
+ * The main program entry point of the commandline tool.
+ *
+ * <p>
+ * The commandline uses the PDF-AS API.
+ * </p>
+ *
+ * @author wprinz
+ */
+public abstract class Main
+{
+// 23.11.2010 changed by exthex - added parameters for placeholder handling
+ /**
+ * Command line parameter setting the application mode sign|verify
+ */
+ protected static final String PARAMETER_MODE = "-mode";
+
+ /**
+ * Command line parameter setting the application to connect
+ */
+ protected static final String PARAMETER_CONNECTOR = "-connector";
+
+ /**
+ * Command line parameter setting the signature mode.
+ */
+ protected static final String PARAMETER_SIGNATURE_MODE = "-sigmode";
+
+ /**
+ * Command line parameter setting the signature type.
+ */
+ protected static final String PARAMETER_SIGNATURE_TYPE = "-sigtype";
+
+ /**
+ * Command line parameter setting the username
+ */
+ protected static final String PARAMETER_USER_NAME = "-username";
+
+ /**
+ * Command line parameter setting the users password
+ */
+ protected static final String PARAMETER_USER_PASSWORD = "-password";
+
+ /**
+ * Command line parameter selecting the position of the signature.
+ */
+ protected static final String PARAMETER_POS = "-pos";
+
+ /**
+ * Command line parameter signaling to search the source document for a placeholder for the signature
+ */
+ protected static final String PARAMETER_PLACEHOLDER_SEARCH = "-searchplaceholder";
+
+ /**
+ * Command line parameter selecting the id of the placeholder to use
+ */
+ protected static final String PARAMETER_PLACEHOLDER_ID = "-placeholder_id";
+
+ /**
+ * Command line parameter selecting the match mode for the placeholder
+ */
+ protected static final String PARAMETER_PLACEHOLDER_MATCH_MODE = "-placeholder_matchmode";
+
+ /**
+ * Command line parameter selecting the signature which is going to be
+ * verified.
+ */
+ protected static final String PARAMETER_VERIFY_WHICH = "-verify_which";
+
+ /**
+ * Command line parameter that starts the deployment of the default configuration to the current
+ * user's home folder.
+ * @see Constants#USERHOME_CONFIG_FOLDER
+ */
+ protected static final String PARAMETER_DEPLOY_DEFAULT_CONFIGURATION = "-ddc";
+
+ /**
+ * The application mode sign
+ */
+ public static final String VALUE_MODE_SIGN = "sign";
+
+ /**
+ * The application mode verify
+ */
+ public static final String VALUE_MODE_VERIFY = "verify";
+
+ /**
+ * The value for signature mode binary.
+ */
+ public static final String VALUE_SIGNATURE_MODE_BINARY = Constants.SIGNATURE_TYPE_BINARY;
+
+ /**
+ * The value for signature mode textual.
+ */
+ public static final String VALUE_SIGNATURE_MODE_TEXTUAL = Constants.SIGNATURE_TYPE_TEXTUAL;
+
+ /**
+ * The value for signature mode detached.
+ */
+ public static final String VALUE_SIGNATURE_MODE_DETACHED = "detached";
+
+ /**
+ * The value for signature mode detachedtextual.
+ */
+ public static final String VALUE_SIGNATURE_MODE_DETACHED_TEXT = Constants.SIGNATURE_TYPE_DETACHEDTEXTUAL;
+
+ /**
+ * The placeholder match mode STRICT
+ */
+ public static final String VALUE_PLACEHOLDER_MATCH_MODE_STRICT = "strict";
+
+ /**
+ * The placeholder match mode STRICT
+ */
+ public static final String VALUE_PLACEHOLDER_MATCH_MODE_MODERATE = "moderate";
+
+ /**
+ * The placeholder match mode STRICT
+ */
+ public static final String VALUE_PLACEHOLDER_MATCH_MODE_LENIENT = "lenient";
+
+ /**
+ * The log.
+ */
+ private static final Log logger_ = LogFactory.getLog(Main.class);
+
+ /**
+ * Main program entry point.
+ *
+ * @param args
+ * The commandline arguments.
+ * @throws IOException
+ */
+ public static void main(String[] args) throws IOException
+ {
+ // ConfigLogger.setLevel(Level.DEBUG);
+
+ // search for PARAMETER_DEPLOY_DEFAULT_CONFIGURATION before initializing the SettingsReader
+ for (int i = 0; i < args.length; i++) {
+ if (args[i].trim().equals(PARAMETER_DEPLOY_DEFAULT_CONFIGURATION)) {
+ try {
+ String defaultConfigurationDeployedTo = ConfigUtils.deployDefaultConfiguration();
+ if (defaultConfigurationDeployedTo != null) {
+ System.out.println("Default configuration successfully deployed to \"" + defaultConfigurationDeployedTo + "\".");
+ } else {
+ System.out.println("Default configuration has NOT been deployed. Maybe the configuration already exists.");
+ }
+ if (args.length == 1) {
+ // no other parameters supplied; exit application
+ System.exit(0);
+ }
+ } catch (ConfigUtilsException e) {
+ System.err.println("Deployment of default configuration failed: " + e.getMessage());
+ System.exit(1);
+ }
+ }
+ }
+
+ SettingsReader.initializeForCommandLine();
+ ConfigUtils.initializeLogger();
+
+ // printUsage(System.out);
+
+ String mode = null;
+ String signature_mode = Constants.DEFAULT_SIGNATURE_TYPE;
+ String connector = null;
+
+ String signature_type = null;
+ String user_name = null;
+ String user_password = null;
+ String pos_string = null;
+
+ boolean search_placeholder = true;
+ String placeholderId = null;
+ int placeholderMatchMode = Constants.PLACEHOLDER_MATCH_MODE_MODERATE;
+
+ int verify_which = -1;
+
+ String input = null;
+ String output = null;
+
+ try
+ {
+ // force settings preload
+ SettingsReader.getInstance();
+
+ // for (int i = 0; i < args.length; i++)
+ // {
+ // logger_.debug("arg[" + i + "] = " + args[i]);
+ // }
+
+ for (int i = 0; i < args.length; i++)
+ {
+ String cur_arg = args[i].trim();
+
+ if (cur_arg.equals(PARAMETER_DEPLOY_DEFAULT_CONFIGURATION)) {
+ // already applied
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_MODE))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_MODE);
+ return;
+ }
+ mode = args[i];
+ if (!checkMode(mode))
+ {
+ printUnrecognizedValue(PARAMETER_MODE, mode);
+ return;
+ }
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_CONNECTOR))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_CONNECTOR);
+ return;
+ }
+ connector = args[i];
+ if (!checkConnector(connector))
+ {
+ printUnrecognizedValue(PARAMETER_CONNECTOR, connector);
+ return;
+ }
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_SIGNATURE_MODE))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_SIGNATURE_MODE);
+ return;
+ }
+ signature_mode = args[i];
+ if (!checkSignatureMode(signature_mode))
+ {
+ printUnrecognizedValue(PARAMETER_SIGNATURE_MODE, signature_mode);
+ return;
+ }
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_SIGNATURE_TYPE))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_SIGNATURE_TYPE);
+ return;
+ }
+ signature_type = args[i];
+ if (!checkSignatureType(signature_type))
+ {
+ printUnrecognizedValue(PARAMETER_SIGNATURE_TYPE, signature_type);
+ return;
+ }
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_PLACEHOLDER_SEARCH))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_PLACEHOLDER_SEARCH);
+ return;
+ }
+ search_placeholder = Boolean.valueOf(args[i]).booleanValue();
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_PLACEHOLDER_ID))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_PLACEHOLDER_ID);
+ return;
+ }
+ placeholderId = args[i];
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_PLACEHOLDER_MATCH_MODE))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_PLACEHOLDER_MATCH_MODE);
+ return;
+ }
+ String matchMode = args[i];
+ if (matchMode.equals(VALUE_PLACEHOLDER_MATCH_MODE_LENIENT))
+ placeholderMatchMode = Constants.PLACEHOLDER_MATCH_MODE_LENIENT;
+ else if (matchMode.equals(VALUE_PLACEHOLDER_MATCH_MODE_MODERATE))
+ placeholderMatchMode = Constants.PLACEHOLDER_MATCH_MODE_MODERATE;
+ else if (matchMode.equals(VALUE_PLACEHOLDER_MATCH_MODE_STRICT))
+ placeholderMatchMode = Constants.PLACEHOLDER_MATCH_MODE_STRICT;
+ else
+ printUnrecognizedValue(PARAMETER_PLACEHOLDER_MATCH_MODE, args[i]);
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_USER_NAME))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_USER_NAME);
+ return;
+ }
+ user_name = args[i];
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_USER_PASSWORD))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_USER_PASSWORD);
+ return;
+ }
+ user_password = args[i];
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_POS))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_POS);
+ return;
+ }
+ pos_string = args[i];
+ continue;
+ }
+
+ if (cur_arg.equals(PARAMETER_VERIFY_WHICH))
+ {
+ i++;
+ if (i >= args.length)
+ {
+ printNoValue(PARAMETER_VERIFY_WHICH);
+ return;
+ }
+ String str_verify_which = args[i];
+ try
+ {
+ verify_which = Integer.parseInt(str_verify_which);
+ }
+ catch (NumberFormatException e)
+ {
+ printUnrecognizedValue(PARAMETER_VERIFY_WHICH, str_verify_which);
+ return;
+ }
+
+ continue;
+ }
+
+ if (cur_arg.charAt(0) == '-')
+ {
+ printUnrecognizedOption(cur_arg);
+ return;
+ }
+
+ if (input == null)
+ {
+ input = cur_arg;
+ continue;
+ }
+
+ if (output == null)
+ {
+ output = cur_arg;
+ continue;
+ }
+
+ printUnrecognizedAdditionalCommandlineArgument(cur_arg);
+ return;
+ }
+
+ if (mode == null)
+ {
+ printMissingParameter("a mode", PARAMETER_MODE);
+ return;
+ }
+ if (connector == null)
+ {
+ printMissingParameter("a connector", PARAMETER_CONNECTOR);
+ return;
+ }
+ if (mode.equals(VALUE_MODE_SIGN))
+ {
+ if (signature_mode == null)
+ {
+ printMissingParameter("a signature mode", PARAMETER_SIGNATURE_MODE);
+ return;
+ }
+ if (signature_type == null)
+ {
+ SettingsReader settings = SettingsReader.getInstance();
+ String default_type = settings.getValueFromKey(SignatureTypes.DEFAULT_TYPE);
+ signature_type = default_type;
+ }
+ if (user_name == null)
+ {
+ user_name = "";
+ // printMissingParameter("a user name", PARAMETER_USER_NAME);
+ // return;
+ }
+ if (user_password == null)
+ {
+ user_password = "";
+ // printMissingParameter("a user password", PARAMETER_USER_PASSWORD);
+ // return;
+ }
+ }
+
+ if (input == null)
+ {
+ printMissing("an input document");
+ return;
+ }
+
+ File file = new File(input);
+ if (!file.exists())
+ {
+ System.err.println("The input file '" + input + "' doesn't exist.");
+ return;
+ }
+
+ if (mode.equals(VALUE_MODE_SIGN) && output == null)
+ {
+ output = generateOutputFileNameFromInput(input, signature_mode);
+ }
+
+ carryOutCommand(mode, signature_mode, connector, signature_type, user_name, user_password, verify_which, input, output, pos_string, search_placeholder, placeholderId, placeholderMatchMode);
+
+ }
+ catch (PdfAsException e)
+ {
+ printPresentableException(e);
+
+ if (output != null)
+ {
+ File oFile = new File(output);
+ if (oFile.exists()) {
+ logger_.debug("Deleting output file on error.");
+ boolean deleted = oFile.delete();
+ if (!deleted)
+ {
+ logger_.error("Couldn't delete output file " + output);
+ }
+ }
+ }
+ }
+ finally
+ {
+ SettingsReader.clearTemporaryDirectory();
+ }
+ }
+
+ protected static void carryOutCommand(final String mode, final String signature_mode, final String connector, final String signature_type, final String user_name, final String user_password,
+ final int verify_which, final String input, String output, final String pos_string, boolean search_placeholder, String placeholderId, int placeholderMatchMode) throws PdfAsException
+ {
+ // File file = new File(input);
+ //
+ // byte[] input_bytes = null;
+ // try
+ // {
+ // FileInputStream fis = new FileInputStream(file);
+ // input_bytes = new byte[(int) file.length()];
+ // fis.read(input_bytes);
+ // fis.close();
+ // }
+ // catch (IOException e)
+ // {
+ // throw new PDFDocumentException(201);
+ // }
+
+ PrintWriter messageOutput = new PrintWriter(System.out);
+
+ if (mode.equals(VALUE_MODE_SIGN))
+ {
+ carryOutSign(input, connector, signature_mode, signature_type, pos_string, user_name, user_password, output, messageOutput, search_placeholder, placeholderId, placeholderMatchMode);
+ }
+ else
+ {
+ carryOutVerify(input, connector, verify_which, messageOutput);
+ }
+ messageOutput.flush();
+ }
+
+ public static void carryOutSign(String input, String connector, String signature_mode, String signature_type, String pos_string, String user_name, String user_password, String output,
+ PrintWriter messageOutput, boolean search_placeholder, String placeholderId, int placeholderMatchMode) throws PdfAsException
+ {
+ messageOutput.println("Signing " + input + "...");
+
+ // for performance measurement
+ long startTime = 0;
+ long fileSize = 0;
+ if (logger_.isInfoEnabled())
+ {
+ startTime = System.currentTimeMillis();
+ }
+
+ DataSource dataSource = null;
+ try
+ {
+ File file = new File(input);
+ dataSource = new FileBasedDataSource(file, "application/pdf");
+ if (logger_.isDebugEnabled())
+ {
+ fileSize = file.length();
+ }
+ }
+ catch (IOException e)
+ {
+ throw new PDFDocumentException(201, e);
+ }
+
+ DataSink dataSink = null;
+ File outputFile = null;
+ try
+ {
+ outputFile = new File(output);
+
+ dataSink = new FileBasedDataSink(outputFile);
+ }
+ catch (IOException e)
+ {
+ throw new PDFDocumentException(ErrorCode.CANNOT_WRITE_PDF, e);
+ }
+
+ try {
+ processSign(dataSource, connector, signature_mode, signature_type, pos_string, search_placeholder, placeholderId, placeholderMatchMode, dataSink);
+ } catch (Exception e) {
+ // Exception caught in order to delete file based datasink
+ if (outputFile != null && outputFile.exists())
+ {
+ logger_.debug("Deleting output file on error.");
+ boolean deleted = outputFile.delete();
+ if (!deleted)
+ {
+ logger_.error("Couldn't delete output file " + output);
+ }
+ }
+ if (e instanceof PresentableException) {
+ throw (PresentableException)e;
+ } else {
+ logger_.error(e);
+ throw new PresentableException(ErrorCode.UNKNOWN_ERROR, e);
+ }
+ }
+
+ // for performance measurement
+ if (logger_.isInfoEnabled())
+ {
+ long endTime = System.currentTimeMillis();
+ String toReport = "SIGN;" + signature_mode + ";" + input + ";" + fileSize + ";" + (endTime - startTime);
+ logger_.info(toReport);
+ }
+
+ messageOutput.println("Signing was successful (" + output + ").");
+ }
+
+ public static void carryOutVerify(String input, String connector, int verify_which, PrintWriter messageOutput) throws PdfAsException
+ {
+ messageOutput.println("Verifying " + input + "...");
+
+ // for performance measurement
+ long startTime = 0;
+ long fileSize = 0;
+ if (logger_.isInfoEnabled())
+ {
+ startTime = System.currentTimeMillis();
+ }
+
+ DataSource dataSource = null;
+ try
+ {
+ File file = new File(input);
+ if (logger_.isDebugEnabled())
+ {
+ fileSize = file.length();
+ }
+ String extension = extractExtension(input);
+ if (extension != null && extension.equals("txt"))
+ {
+ try
+ {
+ FileInputStream fis = new FileInputStream(file);
+ byte[] input_bytes = new byte[(int) file.length()];
+ fis.read(input_bytes);
+ fis.close();
+
+ String text = new String(input_bytes, "UTF-8");
+ dataSource = new StringTextBasedDataSource(text);
+ }
+ catch (UnsupportedEncodingException e)
+ {
+ throw new RuntimeException("Very strange: UTF-8 character encoding not supported.", e);
+ }
+ }
+ else
+ {
+ dataSource = new FileBasedDataSource(file, "application/pdf");
+ }
+ }
+ catch (IOException e)
+ {
+ throw new PDFDocumentException(ErrorCode.DOCUMENT_CANNOT_BE_READ, e);
+ }
+
+ VerifyResults results = processVerify(dataSource, connector, verify_which);
+
+ messageOutput.println("Verification results:");
+ formatVerifyResults(results, messageOutput);
+
+ // for performance measurement
+ if (logger_.isInfoEnabled())
+ {
+ long endTime = System.currentTimeMillis();
+ String toReport = "VERIFY;" + input + ";" + fileSize + ";" + (endTime - startTime) + ";" + debugVerifyResults(results);
+ logger_.info(toReport);
+ }
+
+ }
+
+ /**
+ * Extracts the extension from a file name string.
+ *
+ * <p>
+ * The extension of a file name is whatever text follows the last '.'.
+ * </p>
+ *
+ * @param file_name
+ * The file name.
+ * @return Returns the extension. If the file name ends with the '.', then an
+ * empty string is returned. If the file name doesn't contain any '.'
+ * or file_name is null, null is returned.
+ */
+ public static String extractExtension(String file_name)
+ {
+ if (file_name == null)
+ {
+ return null;
+ }
+
+ int dot_index = file_name.lastIndexOf('.');
+ if (dot_index < 0)
+ {
+ return null;
+ }
+ return file_name.substring(dot_index + 1);
+ }
+
+ public static void processSign(DataSource dataSource, String connector, String signature_mode, String signature_type, String pos_string, boolean search_placeholder, String placeholderId, int placeholderMatchMode, DataSink dataSink) throws PdfAsException
+ {
+ TablePos pos = null;
+ if (pos_string != null)
+ {
+ try
+ {
+ pos = PdfAS.parsePositionFromPosString(pos_string);
+ }
+ catch (PDFDocumentException e)
+ {
+ printUnrecognizedValue(PARAMETER_POS, pos_string);
+ return;
+
+ }
+ }
+ SignaturePositioning posi = null;
+ if (pos != null)
+ {
+ posi = new SignaturePositioning();
+ if (!pos.isXauto())
+ {
+ posi.setXAlgorithm(new AbsoluteAxisAlgorithm(pos.getPosX()));
+ }
+ if (!pos.isYauto())
+ {
+ posi.setYAlgorithm(new AbsoluteAxisAlgorithm(pos.getPosY()));
+ }
+ if (!pos.isWauto())
+ {
+ posi.setWidthAlgorithm(new AbsoluteAxisAlgorithm(pos.getWidth()));
+ }
+ if (pos.isNewPage())
+ {
+ posi.setPageAlgorithm(new NewPageAlgorithm());
+ }
+ if (!pos.isPauto())
+ {
+ posi.setPageAlgorithm(new AbsolutePageAlgorithm(pos.getPage()));
+ }
+ posi.setFooterLine(pos.getFooterLine());
+ }
+
+ PdfAs pdfAs = PdfAsFactory.createPdfAs(new File(SettingsReader.RESOURCES_PATH));
+
+ SignParameters sp = new SignParameters();
+ sp.setDocument(dataSource);
+ sp.setOutput(dataSink);
+ sp.setSignatureType(signature_mode); // TODO detached signaturen!
+ sp.setSignatureDevice(connector);
+ sp.setSignatureProfileId(signature_type);
+ sp.setSignaturePositioning(posi);
+ sp.setCheckForPlaceholder(search_placeholder);
+ sp.setPlaceholderId(placeholderId);
+ sp.setPlaceholderMatchMode(placeholderMatchMode);
+ pdfAs.sign(sp);
+
+ }
+
+ public static VerifyResults processVerify(DataSource dataSource, String connector, int verify_which) throws PdfAsException
+ {
+ String verifyMode = Constants.VERIFY_MODE_FULL_CONSERVATIVE;
+ VerificationFilterParameters parameters = SettingsHelper.readVerificationFilterParametersFromSettings();
+ if (parameters.extractBinarySignaturesOnly())
+ {
+ verifyMode = Constants.VERIFY_MODE_BINARY_ONLY;
+ }
+ else
+ {
+ if (parameters.assumeOnlySignatureUpdateBlocks())
+ {
+ verifyMode = Constants.VERIFY_MODE_SEMI_CONSERVATIVE;
+ }
+ else
+ {
+ verifyMode = Constants.VERIFY_MODE_FULL_CONSERVATIVE;
+ }
+ }
+
+ PdfAs pdfAs = PdfAsFactory.createPdfAs(new File(SettingsReader.RESOURCES_PATH));
+
+ VerifyParameters vp = new VerifyParameters();
+ vp.setDocument(dataSource);
+ vp.setVerifyMode(verifyMode);
+ vp.setSignatureDevice(connector);
+ vp.setReturnHashInputData(false);
+ vp.setVerificationTime(null);
+ vp.setSignatureToVerify(verify_which);
+ VerifyResults vrs = pdfAs.verify(vp);
+
+ return vrs;
+ }
+
+ protected static String generateOutputFileNameFromInput(String input, String sig_mode)
+ {
+ String output = input + "_out";
+ if (sig_mode.startsWith("detached"))
+ {
+ output += ".xml";
+ }
+ else
+ {
+ output += ".pdf";
+ }
+
+ return output;
+ }
+
+ /**
+ * Prints that the provided option was unrecognized.
+ *
+ * @param option
+ * The unrecognized option.
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ protected static void printUnrecognizedOption(final String option) throws PresentableException
+ {
+ System.err.println("Unrecognized option '" + option + "'.");
+ printUsage(System.out);
+ }
+
+ /**
+ * Prints that the provided value was unrecognized.
+ *
+ * @param parameter
+ * The parameter, which is missing a value.
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ protected static void printNoValue(final String parameter) throws PresentableException
+ {
+ System.err.println("The parameter " + parameter + " requires a value as next argument.");
+ printUsage(System.out);
+ }
+
+ /**
+ * Prints that the provided value was unrecognized.
+ *
+ * @param value
+ * The unrecognized value.
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ protected static void printUnrecognizedValue(final String parameter, final String value) throws PresentableException
+ {
+ System.err.println("The parameter " + parameter + " doesn't recognize the provided value '" + value + "'.");
+ printUsage(System.out);
+ }
+
+ /**
+ * Prints that the provided additional commandline argument was unrecognized.
+ *
+ * @param argument
+ * The unrecognized argument.
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ protected static void printUnrecognizedAdditionalCommandlineArgument(final String argument) throws PresentableException
+ {
+ System.err.println("Unrecognized additional commandline argument '" + argument + "'.");
+ printUsage(System.out);
+ }
+
+ /**
+ * Prints that a certain parameter was missing.
+ *
+ * @param missing_term
+ * A description of the missing parameter ("e.g. a mode").
+ * @param parameter
+ * The missing parameter itself (e.g. "-mode").
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ protected static void printMissingParameter(final String missing_term, final String parameter) throws PresentableException
+ {
+ printMissing(missing_term + " ('" + parameter + "' parameter)");
+ }
+
+ /**
+ * Prints that something is missing.
+ *
+ * @param missing_term
+ * A descriptive message of the missing thing.
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ protected static void printMissing(final String missing_term) throws PresentableException
+ {
+ System.err.println("Please specify " + missing_term + ".");
+ printUsage(System.out);
+ }
+
+ /**
+ * Prints out the ErrorCodeException in a descriptive form.
+ *
+ * @param ece
+ * The ErrorCodeException to be printed.
+ */
+ protected static void printPresentableException(final PdfAsException e)
+ {
+ String errorMessage = ErrorCodeHelper.formErrorMessage(e);
+ System.err.println(errorMessage);
+// if (e.getErrorCode() == ErrorCode.PLACEHOLDER_EXCEPTION)
+// {
+// PlaceholderException phe = null;
+// if (e instanceof PlaceholderException)
+// {
+// phe = (PlaceholderException) e;
+// }
+// else
+// {
+// phe = (PlaceholderException) e.getCause();
+// }
+//
+// System.err.println("Der Platzhalter des Feldes " + phe.getField() + " ist um " + phe.getMissing() + " Bytes zu kurz. ");
+// }
+//
+// System.err.println("Fehler " + e.getErrorCode() + ": " + ErrorCodeHelper.getMessageForErrorCode(e.getErrorCode()));
+//
+// if (e instanceof ExternalErrorException)
+// {
+// ExternalErrorException eee = (ExternalErrorException) e;
+// System.err.println("Externer Fehlergrund: " + eee.getExternalErrorCode() + ": " + eee.getExternalErrorMessage());
+// }
+
+ logger_.error(e);
+ }
+
+ /**
+ * Prints the usage text.
+ *
+ * @param writer
+ * The writer to print the text to.
+ * @throws PresentableException
+ * Forwarded exception.
+ */
+ public static void printUsage(PrintStream writer) throws PresentableException
+ {
+ writer.println("Usage: pdf-as [[OPTIONS] <input file> [output file]|UTILOPTIONS]");
+ writer.println(" Required OPTIONS:");
+
+ writer.println(" " + PARAMETER_MODE + " <" + VALUE_MODE_SIGN + "|" + VALUE_MODE_VERIFY + ">");
+ writer.println(" " + VALUE_MODE_SIGN + " ... signs a document");
+ writer.println(" " + VALUE_MODE_VERIFY + " ... verifies a document");
+
+ writer.print(" " + PARAMETER_CONNECTOR + " ");
+ ConnectorInformation[] ci = ConnectorFactory.getConnectorInformationArray();
+
+ // prepare list of connectors available for commandline
+ ArrayList ciList = new ArrayList();
+ for (int i = 0; i < ci.length; i++) {
+ String id = ci[i].getIdentifier();
+ if (ConnectorFactory.isAvailableForCommandline(id)) {
+ ciList.add(ci[i]);
+ }
+ }
+
+ // list available connectors wrapped in <...|...>
+ Iterator ciIt = ciList.iterator();
+ writer.print("<");
+ while (ciIt.hasNext()) {
+ writer.print(((ConnectorInformation) ciIt.next()).getIdentifier());
+ if (ciIt.hasNext()) {
+ writer.print("|");
+ }
+ }
+ writer.print(">");
+ writer.println();
+
+// for (int i = 0; i < ci.length; i++)
+// {
+// String id = ci[i].getIdentifier();
+// if (!ConnectorFactory.isAvailableForCommandline(id))
+// {
+// continue;
+// }
+// writer.print(id);
+// if (i < ci.length - 1)
+// {
+// writer.print("|");
+// }
+// }
+ ciIt = ciList.iterator();
+ while (ciIt.hasNext()) {
+ ConnectorInformation cinf = (ConnectorInformation) ciIt.next();
+ writer.println(" " + cinf.getIdentifier() + " ... " + cinf.getDescription());
+ }
+
+// for (int i = 0; i < ci.length; i++)
+// {
+// String id = ci[i].getIdentifier();
+// if (!ConnectorFactory.isAvailableForCommandline(id))
+// {
+// continue;
+// }
+// writer.println(" " + id + " ... " + ci[i].getDescription());
+// }
+
+ writer.println(" UTILity OPTIONS");
+
+ writer.println(" " + PARAMETER_DEPLOY_DEFAULT_CONFIGURATION + " ... deploys the default configuration to the current user's home");
+
+ writer.println(" OPTIONS for signation:");
+
+ writer.println(" " + PARAMETER_SIGNATURE_MODE + " <" + VALUE_SIGNATURE_MODE_BINARY + "|" + VALUE_SIGNATURE_MODE_TEXTUAL + "> [optional]");
+ writer.println(" " + VALUE_SIGNATURE_MODE_BINARY + " ... signs the complete binary document" + (Constants.DEFAULT_SIGNATURE_TYPE.equals(VALUE_SIGNATURE_MODE_BINARY) ? " (default)" : ""));
+ writer.println(" " + VALUE_SIGNATURE_MODE_TEXTUAL + " ... signs only the textual portion of the document" + (Constants.DEFAULT_SIGNATURE_TYPE.equals(VALUE_SIGNATURE_MODE_TEXTUAL) ? " (default)" : ""));
+ writer.println(" " + VALUE_SIGNATURE_MODE_DETACHED_TEXT + " ... signs the document using the textual mode and returns the xml signature of it." + (Constants.DEFAULT_SIGNATURE_TYPE.equals(VALUE_SIGNATURE_MODE_DETACHED_TEXT) ? " (default)" : ""));
+
+ writer.print(" " + PARAMETER_SIGNATURE_TYPE + " <");
+ SignatureTypes sig_types = SignatureTypes.getInstance();
+ SettingsReader settings = SettingsReader.getInstance();
+ Set types_array = sig_types.getSignatureTypes();
+ Iterator it = types_array.iterator();
+ while (it.hasNext())
+ {
+ String type = (String) it.next();
+ writer.print(type);
+ if (it.hasNext())
+ {
+ writer.print("|");
+ }
+ }
+ writer.println(">");
+ writer.println(" ... [optional] the profile to be used. If omitted, the default");
+ writer.println(" profile is used.");
+ String default_type = settings.getValueFromKey(SignatureTypes.DEFAULT_TYPE);
+ it = types_array.iterator();
+ while (it.hasNext())
+ {
+ String type = (String) it.next();
+ String descr_key = SignatureTypes.SIG_OBJ + type + "." + SignatureTypes.SIG_DESCR;
+ String type_descr = settings.getValueFromKey(descr_key);
+
+ writer.println(" " + type + " ... " + (type.equals(default_type) ? "(default) " : "") + type_descr);
+ }
+
+ writer.println(" " + PARAMETER_USER_NAME + " <user_name> ... [optional] the user name");
+ writer.println(" " + PARAMETER_USER_PASSWORD + " <password> ... [optional] the user password");
+
+ writer.println(" " + PARAMETER_POS + " <position> ... [optional] the position of the signature block");
+ writer.println(" position has the format [x:x_algo];[y:y_algo];[w:w_algo][p:p_algo];[f:f_algo]");
+ writer.println(" if not present default is set to x:auto;y:auto;w:auto;p:auto;f:0");
+ writer.println(" x_algo:='auto' ... automatic positioning x");
+ writer.println(" floatvalue ... absolute x must be >= 0");
+ writer.println(" y_algo:='auto' ... automatic positioning y");
+ writer.println(" floatvalue ... absolute y must be >= 0");
+ writer.println(" w_algo:='auto' ... automatic width");
+ writer.println(" floatvalue ... absolute width must be > 0");
+ writer.println(" p_algo:='auto' ... automatic last page");
+ writer.println(" 'new' ... new page");
+ writer.println(" intvalue ... pagenumber must be > 0 if p>number of pages in document p-->handled like p:'new'");
+ writer.println(" f_algo floatvalue ... consider footerline must be >= 0 (only if y_algo is auto and p_algo is not 'new')");
+
+ writer.println(" " + PARAMETER_PLACEHOLDER_SEARCH + " <true|false> ... [optional] if set to true, the source document will be scanned for signature placeholder images. If not set, the enable_placeholder_search value in the config file decides whether or not a search for placeholder images will be performed.");
+ writer.println(" " + PARAMETER_PLACEHOLDER_ID + " <id> ... [optional] search for signature placeholder images containing the given id");
+ writer.println(" " + PARAMETER_PLACEHOLDER_MATCH_MODE + " <" + VALUE_PLACEHOLDER_MATCH_MODE_LENIENT + "|" + VALUE_PLACEHOLDER_MATCH_MODE_MODERATE + "|" + VALUE_PLACEHOLDER_MATCH_MODE_STRICT + "> ... [optional] specify the behavior if no matching placeholder could be found. Default is <moderate>.");
+ writer.println(" " + VALUE_PLACEHOLDER_MATCH_MODE_LENIENT + " ... sign in place of the first found placeholder, regardless if it matches exactly, or at the end of the document if none is found.");
+ writer.println(" " + VALUE_PLACEHOLDER_MATCH_MODE_MODERATE + " ... sign in place of the first found placeholder which has no explicit id set, or at the end of the document if none is found.");
+ writer.println(" " + VALUE_PLACEHOLDER_MATCH_MODE_STRICT + " ... throws a PlaceholderExtractionException.");
+
+ writer.println(" OPTIONS for verification:");
+ writer.println(" " + PARAMETER_VERIFY_WHICH + " <number> ... [optional] zero based number of the signature");
+ writer.println(" to be verified. If omitted, all signatures are verified.");
+
+ writer.println(" Example usage:");
+ writer.println(" pdf-as " + PARAMETER_MODE + " " + VALUE_MODE_SIGN + " " + PARAMETER_CONNECTOR + " " + Constants.SIGNATURE_DEVICE_BKU + " " + PARAMETER_SIGNATURE_MODE + " " + VALUE_SIGNATURE_MODE_TEXTUAL + " some_document.pdf");
+ writer.println(" pdf-as " + PARAMETER_MODE + " " + VALUE_MODE_VERIFY + " " + PARAMETER_CONNECTOR + " " + Constants.SIGNATURE_DEVICE_BKU + " some_document.pdf_out.pdf");
+ writer.println(" pdf-as " + PARAMETER_DEPLOY_DEFAULT_CONFIGURATION);
+ }
+
+ /**
+ * Checks the value for correctness.
+ *
+ * @param mode
+ * The parameter's value.
+ * @return Returns true, if the value is correct, false otherwise.
+ */
+ protected static boolean checkMode(String mode)
+ {
+ return mode.equals(VALUE_MODE_SIGN) || mode.equals(VALUE_MODE_VERIFY);
+ }
+
+ /**
+ * Checks the value for correctness.
+ *
+ * @param signature_mode
+ * The parameter's value.
+ * @return Returns true, if the value is correct, false otherwise.
+ */
+ protected static boolean checkSignatureMode(String signature_mode)
+ {
+ return signature_mode.equals(VALUE_SIGNATURE_MODE_BINARY) || signature_mode.equals(VALUE_SIGNATURE_MODE_TEXTUAL)
+ //|| signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED)
+ || signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED_TEXT);
+ }
+
+ /**
+ * Checks the value for correctness.
+ *
+ * @param connector
+ * The parameter's value.
+ * @return Returns true, if the value is correct, false otherwise.
+ * @throws ConnectorFactoryException
+ * F.e.
+ */
+ protected static boolean checkConnector(String connector) throws ConnectorFactoryException
+ {
+ return ConnectorFactory.isValidConnectorIdentifier(connector) && ConnectorFactory.isAvailableForCommandline(connector);
+ }
+
+ /**
+ * Checks the value for correctness (meaning if it exists)
+ *
+ * @param signature_type
+ * The parameter's value.
+ * @return Returns true, if the value is correct, false otherwise.
+ */
+ protected static boolean checkSignatureType(String signature_type) throws SignatureTypesException
+ {
+ return SignatureTypes.getInstance().getSignatureTypes().contains(signature_type);
+ }
+
+ /**
+ * Translates the commandline argument to a PDF-AS-ID.
+ *
+ * @param signature_mode
+ * The signator mode commandline argument.
+ * @return Returns the corresponding PDFASID.
+ */
+ protected static PdfASID translateSignatureModeToPdfASID(String signature_mode)
+ {
+ if (signature_mode.equals(VALUE_SIGNATURE_MODE_BINARY))
+ {
+ return SignatorFactory.MOST_RECENT_BINARY_SIGNATOR_ID;
+ }
+ if (signature_mode.equals(VALUE_SIGNATURE_MODE_TEXTUAL))
+ {
+ return SignatorFactory.MOST_RECENT_TEXTUAL_SIGNATOR_ID;
+ }
+ if (signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED))
+ {
+ return SignatorFactory.MOST_RECENT_DETACHED_SIGNATOR_ID;
+ }
+ if (signature_mode.equals(VALUE_SIGNATURE_MODE_DETACHED_TEXT))
+ {
+ return SignatorFactory.MOST_RECENT_DETACHEDTEXT_SIGNATOR_ID;
+ }
+ return null;
+ }
+
+ /**
+ * Formats the verification results.
+ *
+ * @param results
+ * The List of SignatureResponse verification results.
+ * @param writer
+ * The output sink to write the formatted text to.
+ * @throws SettingNotFoundException
+ * Forwarded exception.
+ */
+ protected static void formatVerifyResults(VerifyResults results, PrintWriter writer) throws SettingNotFoundException
+ {
+ Iterator it = results.getResults().iterator();
+ while (it.hasNext())
+ {
+ VerifyResult result = (VerifyResult) it.next();
+ formatVerifyResult(result, writer);
+
+ if (it.hasNext())
+ {
+ writer.println();
+ }
+ }
+ }
+
+ /**
+ * Formats the verification results for debugging. Returns 0 if no error
+ * occurs or the sum of all error-codes.
+ *
+ * @param results
+ *
+ * @param writer
+ * The output sink to write the formatted text to.
+ * @throws SettingNotFoundException
+ * Forwarded exception.
+ */
+ protected static int debugVerifyResults(VerifyResults results) throws SettingNotFoundException
+ {
+ int toreturn = 0;
+ Iterator it = results.getResults().iterator();
+ while (it.hasNext())
+ {
+ VerifyResult result = (VerifyResult) it.next();
+
+ toreturn += result.getValueCheckCode().getCode();
+ }
+ return toreturn;
+ }
+
+ public static void formatVerifyResult(VerifyResult result, PrintWriter writer) throws SettingNotFoundException
+ {
+
+ if (result.isVerificationDone()) {
+ writer.println(" Zertifikat:");
+ writer.println(" Signator: " + result.getSignerCertificate().getSubjectDN().toString());
+ writer.println(" Aussteller: " + result.getSignerCertificate().getIssuerDN().toString());
+ writer.println(" Seriennummer: " + result.getSignerCertificate().getSerialNumber());
+ List public_properties = result.getPublicProperties();
+ Iterator it = public_properties.iterator();
+ while (it.hasNext())
+ {
+ String public_property = (String) it.next();
+ writer.println(" Eigenschaft: " + public_property);
+ }
+
+ writer.println(" Zertifikat-Check:");
+ writer.println(" " + result.getCertificateCheck().getCode() + " - " + result.getCertificateCheck().getMessage());
+ writer.println(" Signatur-Check:");
+ writer.println(" " + result.getValueCheckCode().getCode() + " - " + result.getValueCheckCode().getMessage());
+ writer.println(" Manifest-Check:");
+ writer.println(" " + result.getManifestCheckCode().getCode() + " - " + result.getManifestCheckCode().getMessage());
+ } else {
+ PdfAsException ex = result.getVerificationException();
+ writer.println("\n Signaturpruefung fuer diese Signatur nicht moeglich: " + ErrorCodeHelper.formErrorMessage(ex));
+ }
+ }
+
+}
|