Compare signed PDF with original (initial) PDF

After making a signature on a PDF document using iText, now I want to make a comparison between the signed document and the original document.

Normally I should have equality between the original document and the signed document (after deleting the signature I think).

How can i do that ?

UPDATE 1 :
here is the function I use for the moment which allows to delete the signature and after checking the two PDFs but the problem is that the return is always FALSE :

 public static void main(String[] args) throws Exception, 
GeneralSecurityException, 
DocumentException {
testRemoveSignatureFromPDFSignedFirmaCerta();
File file1 = new File(SRC);
File file2 = new File(DEST_After_Delete);
boolean compare1and2 = FileUtils.contentEquals(file1, file2);
System.out.println("Are test1.txt and test2.txt the same? " + 
compare1and2);
}
public static void testRemoveSignatureFromPDFSignedFirmaCerta() throws 
IOException, GeneralSecurityException, DocumentException
{
try (   InputStream inputStream = new FileInputStream(DEST);
OutputStream outputStream = new FileOutputStream(new 
File(DEST_After_Delete)))
{
Provider provider = new BouncyCastleProvider();
Security.addProvider(provider);
PdfReader reader = new PdfReader(inputStream, null);
AcroFields af = reader.getAcroFields();
ArrayList<String> names = af.getSignatureNames();
for (String name : names) {
System.out.println("Signature name: " + name);
System.out.println("Signature covers whole document: " + 
af.signatureCoversWholeDocument(name));
PdfPKCS7 pk = af.verifySignature(name, provider.getName());
System.out.println("SignatureDate: " + pk.getSignDate());
System.out.println("Certificate: " + pk.getSigningCertificate());
System.out.println("Document modified: " + !pk.verify());
af.removeField(name);
}
PdfStamper stamper = new PdfStamper(reader, outputStream, '\0');
stamper.close();
}
}

It depends.

When generating integrated PDF signatures, you usually first prepare the PDF by

• selecting an existing or adding a new, empty signature field;
• adding a value dictionary to that field including a place holder for the signature container to embed eventually;
• (optionally) updating the existing or creating a new visualization for the signature;
• (optionally) rendering assorted other form fields read-only if the signature field has a signature lock dictionary;
• (optionally) creating and adding appearances to annotations if those annotations had no appearances yet, so there is no variability in the PDF appearance after signing; and
• (optionally) doing arbitrary other changes, e.g. repairs of invalid or questionable PDF objects etc.

Having saved this prepared PDF, you calculate the hash digest of the byte ranges to sign (essentially everything but the afore mentioned place holder), locally create or remotely request a signature container signing that hash value, and eventually you embed that signature container in the place holder.

There essentially are two ways to apply these changes:

• The PDF can be completely saved anew. In this case the objects modelling the original PDF may be substantially changed, their order in the document may change, compression may change, objects may be renumbered, etc etc etc.
• The changes are appended to the original PDF as an incremental update. In this case the start of the file remains the original PDF byte-by-byte.

(If the signature is applied with iText: applying changes as an incremental update in iText is done by using the append mode.)

In the former case a comparison is very difficult, in particular if there are lots of those "arbitrary other changes". Also you cannot expect to get back the original PDF by removing the signature, it may still be very different internally. I don't have an easy-to-implement idea here.

In the latter case you can easily check whether the signed file indeed is based on the unsigned one by testing whether as a file the signed PDF starts with the bytes of the unsigned one. An evaluation of the changes themselves, though, is difficult here, too.