support reading HSSFWorkbook with password passed as param

Author: pjfanning

poi/src/main/java/org/apache/poi/hssf/record/RecordFactory.java

@@ -172,24 +172,37 @@ public static short[] getAllKnownRecordSIDs() {
      * Create an array of records from an input stream
      *
      * @param in the InputStream from which the records will be obtained
-     *
      * @return a list of Records created from the InputStream
-     *
      * @throws org.apache.poi.util.RecordFormatException on error processing the InputStream
      */
     public static List<org.apache.poi.hssf.record.Record> createRecords(InputStream in) throws RecordFormatException {
+        return createRecords(in, null);
+    }
+
+    /**
+     * Create an array of records from an input stream
+     *
+     * @param in the InputStream from which the records will be obtained
+     * @param password in char array format (can be null)
+     * @return a list of Records created from the InputStream
+     * @throws org.apache.poi.util.RecordFormatException on error processing the InputStream
+     * @since 6.0.0
+     */
+    public static List<org.apache.poi.hssf.record.Record> createRecords(
+            InputStream in, char[] password) throws RecordFormatException {
 
         List<org.apache.poi.hssf.record.Record> records = new ArrayList<>(NUM_RECORDS);
 
-        RecordFactoryInputStream recStream = new RecordFactoryInputStream(in, true);
+        RecordFactoryInputStream recStream = new RecordFactoryInputStream(in, true, password);
 
         Record record;
-        while ((record = recStream.nextRecord())!=null) {
+        while ((record = recStream.nextRecord()) != null) {
             records.add(record);
 
             IOUtils.safelyAllocateCheck(records.size(), MAX_NUMBER_OF_RECORDS);
         }
 
         return records;
     }
+
 }

poi/src/main/java/org/apache/poi/hssf/record/RecordFactoryInputStream.java

@@ -102,19 +102,38 @@ public StreamEncryptionInfo(RecordInputStream rs, List<org.apache.poi.hssf.recor
             _lastRecord = rec;
         }
 
+        /**
+         * This method requires that you store the password in {@link Biff8EncryptionKey}.
+         * Since 6.0.0, we have overloaded methods where you can pass the password as a param instead.
+         */
         @SuppressWarnings({"squid:S2068"})
         public RecordInputStream createDecryptingStream(InputStream original) {
-            String userPassword = Biff8EncryptionKey.getCurrentUserPassword();
-            if (userPassword == null) {
-                userPassword = Decryptor.DEFAULT_PASSWORD;
-            }
+            return createDecryptingStream(original, (String) null);
+        }
 
+        /**
+         * @since 6.0.0
+         */
+        public RecordInputStream createDecryptingStream(InputStream original, char[] password) {
+            return createDecryptingStream(original, new String(password));
+        }
+
+        /**
+         * @since 6.0.0
+         */
+        public RecordInputStream createDecryptingStream(InputStream original, String password) {
+            if (password == null) {
+                password = Biff8EncryptionKey.getCurrentUserPassword();
+                if (password == null) {
+                    password = Decryptor.DEFAULT_PASSWORD;
+                }
+            }
             EncryptionInfo info = _filePassRec.getEncryptionInfo();
             try {
-                if (!info.getDecryptor().verifyPassword(userPassword)) {
+                if (!info.getDecryptor().verifyPassword(password)) {
                     throw new EncryptedDocumentException(
-                            (Decryptor.DEFAULT_PASSWORD.equals(userPassword) ? "Default" : "Supplied")
-                            + " password is invalid for salt/verifier/verifierHash");
+                            (Decryptor.DEFAULT_PASSWORD.equals(password) ? "Default" : "Supplied")
+                                    + " password is invalid for salt/verifier/verifierHash");
                 }
             } catch (GeneralSecurityException e) {
                 throw new EncryptedDocumentException(e);
@@ -176,17 +195,29 @@ public boolean hasBOFRecord() {
 
     /**
      * @param in the InputStream to read from
-     * 
      * @param shouldIncludeContinueRecords caller can pass <code>false</code> if loose
      * {@link ContinueRecord}s should be skipped (this is sometimes useful in event based
      * processing).
      */
     public RecordFactoryInputStream(InputStream in, boolean shouldIncludeContinueRecords) {
+        this(in, shouldIncludeContinueRecords, null);
+    }
+
+    /**
+     * @param in the InputStream to read from
+     * @param shouldIncludeContinueRecords caller can pass <code>false</code> if loose
+     * @param password password in char array format (can be null)
+     * {@link ContinueRecord}s should be skipped (this is sometimes useful in event based
+     * processing).
+     * @since 6.0.0
+     */
+    public RecordFactoryInputStream(InputStream in, boolean shouldIncludeContinueRecords,
+                                    char[] password) {
         RecordInputStream rs = new RecordInputStream(in);
         List<org.apache.poi.hssf.record.Record> records = new ArrayList<>();
         StreamEncryptionInfo sei = new StreamEncryptionInfo(rs, records);
         if (sei.hasEncryption()) {
-            rs = sei.createDecryptingStream(in);
+            rs = sei.createDecryptingStream(in, password);
         } else {
             // typical case - non-encrypted stream
         }
@@ -201,22 +232,22 @@ public RecordFactoryInputStream(InputStream in, boolean shouldIncludeContinueRec
         _lastRecord = sei.getLastRecord();
 
         /*
-        * How to recognise end of stream?
-        * In the best case, the underlying input stream (in) ends just after the last EOF record
-        * Usually however, the stream is padded with an arbitrary byte count.  Excel and most apps
-        * reliably use zeros for padding and if this were always the case, this code could just
-        * skip all the (zero sized) records with sid==0.  However, bug 46987 shows a file with
-        * non-zero padding that is read OK by Excel (Excel also fixes the padding).
-        *
-        * So to properly detect the workbook end of stream, this code has to identify the last
-        * EOF record.  This is not so easy because the worbook bof+eof pair do not bracket the
-        * whole stream.  The worksheets follow the workbook, but it is not easy to tell how many
-        * sheet sub-streams should be present.  Hence we are looking for an EOF record that is not
-        * immediately followed by a BOF record.  One extra complication is that bof+eof sub-
-        * streams can be nested within worksheet streams and it's not clear in these cases what
-        * record might follow any EOF record.  So we also need to keep track of the bof/eof
-        * nesting level.
-        */
+         * How to recognise end of stream?
+         * In the best case, the underlying input stream (in) ends just after the last EOF record
+         * Usually however, the stream is padded with an arbitrary byte count.  Excel and most apps
+         * reliably use zeros for padding and if this were always the case, this code could just
+         * skip all the (zero sized) records with sid==0.  However, bug 46987 shows a file with
+         * non-zero padding that is read OK by Excel (Excel also fixes the padding).
+         *
+         * So to properly detect the workbook end of stream, this code has to identify the last
+         * EOF record.  This is not so easy because the workbook bof+eof pair do not bracket the
+         * whole stream.  The worksheets follow the workbook, but it is not easy to tell how many
+         * sheet sub-streams should be present.  Hence we are looking for an EOF record that is not
+         * immediately followed by a BOF record.  One extra complication is that bof+eof sub-
+         * streams can be nested within worksheet streams and it's not clear in these cases what
+         * record might follow any EOF record.  So we also need to keep track of the bof/eof
+         * nesting level.
+         */
         _bofDepth = sei.hasBOFRecord() ? 1 : 0;
         _lastRecordWasEOFLevelZero = false;
     }

poi/src/main/java/org/apache/poi/hssf/usermodel/HSSFWorkbook.java

@@ -113,7 +113,6 @@ Licensed to the Apache Software Foundation (ASF) under one or more
 import org.apache.poi.util.LittleEndian;
 import org.apache.poi.util.LittleEndianByteArrayInputStream;
 import org.apache.poi.util.LittleEndianByteArrayOutputStream;
-import org.apache.poi.util.Removal;
 
 /**
  * High level representation of a workbook.  This is the first object most users
@@ -205,6 +204,12 @@ public final class HSSFWorkbook extends POIDocument implements Workbook {
      */
     private final UDFFinder _udfFinder = new IndexedUDFFinder(AggregatingUDFFinder.DEFAULT);
 
+    /**
+     * The password needed to decrypt this workbook.
+     * @since 6.0.0
+     */
+    private char[] passwordChars;
+
     public static HSSFWorkbook create(InternalWorkbook book) {
         return new HSSFWorkbook(book);
     }
@@ -325,7 +330,7 @@ public static String getWorkbookDirEntryName(DirectoryNode directory) {
      * low level models.  If you're reading in a workbook...start here.
      *
      * @param directory     the POI filesystem directory to process from
-     * @param fs            the POI filesystem that contains the Workbook stream.
+     * @param fs            the POI filesystem that contains the Workbook stream (ignored).
      * @param preserveNodes whether to preserve other nodes, such as
      *                      macros.  This takes more memory, so only say yes if you
      *                      need to. If set, will store all of the POIFSFileSystem
@@ -334,6 +339,7 @@ public static String getWorkbookDirEntryName(DirectoryNode directory) {
      * @throws IllegalStateException a number of runtime exceptions can be thrown, especially if there are problems with the
      * input format
      * @see POIFSFileSystem
+     * @deprecated the <code>fs</code> param is ignored - use the constructor that omits it
      */
     public HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, boolean preserveNodes)
             throws IOException {
@@ -357,10 +363,33 @@ public HSSFWorkbook(DirectoryNode directory, POIFSFileSystem fs, boolean preserv
      */
     public HSSFWorkbook(DirectoryNode directory, boolean preserveNodes)
             throws IOException {
+        this(directory, preserveNodes, null);
+    }
+
+    /**
+     * given a POI POIFSFileSystem object, and a specific directory
+     * within it, read in its Workbook and populate the high and
+     * low level models.  If you're reading in a workbook...start here.
+     *
+     * @param directory     the POI filesystem directory to process from
+     * @param preserveNodes whether to preserve other nodes, such as
+     *                      macros.  This takes more memory, so only say yes if you
+     *                      need to. If set, will store all of the POIFSFileSystem
+     *                      in memory
+     * @param password      in char array format (can be null)
+     * @throws IOException if the stream cannot be read
+     * @throws IllegalStateException a number of runtime exceptions can be thrown, especially if there are problems with the
+     * input format
+     * @see POIFSFileSystem
+     * @since 6.0.0
+     */
+    public HSSFWorkbook(DirectoryNode directory, boolean preserveNodes, char[] password)
+            throws IOException {
         super(directory);
         String workbookName = getWorkbookDirEntryName(directory);
 
         this.preserveNodes = preserveNodes;
+        this.passwordChars = password;
 
         // If we're not preserving nodes, don't track the
         //  POIFS any more
@@ -375,7 +404,7 @@ public HSSFWorkbook(DirectoryNode directory, boolean preserveNodes)
         //  it happens to be spelled.
         InputStream stream = directory.createDocumentInputStream(workbookName);
 
-        List<org.apache.poi.hssf.record.Record> records = RecordFactory.createRecords(stream);
+        List<org.apache.poi.hssf.record.Record> records = RecordFactory.createRecords(stream, password);
 
         workbook = InternalWorkbook.createWorkbook(records);
         setPropertiesFromWorkbook(workbook);
@@ -418,6 +447,24 @@ public HSSFWorkbook(InputStream s) throws IOException {
         this(s, true);
     }
 
+    /**
+     * Companion to HSSFWorkbook(POIFSFileSystem), this constructs the
+     * POI filesystem around your {@link InputStream}, including all nodes.
+     * <p>This calls {@link #HSSFWorkbook(InputStream, boolean)} with
+     * preserve nodes set to true.
+     *
+     * @throws IOException if the stream cannot be read
+     * @throws IllegalStateException a number of runtime exceptions can be thrown, especially if there are problems with the
+     * input format
+     * @see #HSSFWorkbook(InputStream, boolean)
+     * @see #HSSFWorkbook(POIFSFileSystem)
+     * @see POIFSFileSystem
+     * @since 6.0.0
+     */
+    public HSSFWorkbook(InputStream s, char[] password) throws IOException {
+        this(s, true, password);
+    }
+
     /**
      * Companion to HSSFWorkbook(POIFSFileSystem), this constructs the
      * POI filesystem around your {@link InputStream}.
@@ -439,9 +486,30 @@ public HSSFWorkbook(InputStream s, boolean preserveNodes)
     }
 
     /**
-     * used internally to set the workbook properties.
+     * Companion to HSSFWorkbook(POIFSFileSystem), this constructs the
+     * POI filesystem around your {@link InputStream}.
+     *
+     * @param s             the POI filesystem that contains the Workbook stream.
+     * @param preserveNodes whether to preserve other nodes, such as
+     *                      macros.  This takes more memory, so only say yes if you
+     *                      need to.
+     * @param password      in char array format (can be null)
+     * @throws IOException if the stream cannot be read
+     * @throws IllegalStateException a number of runtime exceptions can be thrown, especially if there are problems with the
+     * input format
+     * @see POIFSFileSystem
+     * @see #HSSFWorkbook(POIFSFileSystem)
+     * @since 6.0.0
      */
+    @SuppressWarnings("resource")   // POIFSFileSystem always closes the stream
+    public HSSFWorkbook(InputStream s, boolean preserveNodes, char[] password)
+            throws IOException {
+        this(new POIFSFileSystem(s).getRoot(), preserveNodes, password);
+    }
 
+    /**
+     * used internally to set the workbook properties.
+     */
     private void setPropertiesFromWorkbook(InternalWorkbook book) {
         this.workbook = book;
 
@@ -1480,7 +1548,6 @@ public int serialize(int offset, byte[] data) {
         }
     }
 
-
     /**
      * Method getBytes - get the bytes of just the HSSF portions of the XLS file.
      * Use this to construct a POI POIFSFileSystem yourself.
@@ -1494,7 +1561,14 @@ public byte[] getBytes() {
         HSSFSheet[] sheets = getSheets();
         int nSheets = sheets.length;
 
-        updateEncryptionInfo();
+        String pwdString;
+        if (passwordChars != null) {
+            pwdString = new String(passwordChars);
+        } else {
+            // from POI 6.0.0, using Biff8EncryptionKey is discouraged
+            pwdString = Biff8EncryptionKey.getCurrentUserPassword();
+        }
+        updateEncryptionInfo(pwdString);
 
         // before getting the workbook size we must tell the sheets that
         // serialization is about to occur.
@@ -2327,12 +2401,11 @@ public EncryptionInfo getEncryptionInfo() {
     }
 
 
-    private void updateEncryptionInfo() {
+    private void updateEncryptionInfo(String password) {
         // make sure, that we've read all the streams ...
         readProperties();
         FilePassRecord fpr = (FilePassRecord) workbook.findFirstRecordBySid(FilePassRecord.sid);
 
-        String password = Biff8EncryptionKey.getCurrentUserPassword();
         WorkbookRecordList wrl = workbook.getWorkbookRecordList();
         if (password == null) {
             if (fpr != null) {

poi/src/test/java/org/apache/poi/hssf/HSSFTestDataSamples.java

@@ -49,6 +49,15 @@ public static HSSFWorkbook openSampleWorkbook(String sampleFileName) {
             throw new RuntimeException(e);
         }
     }
+
+    public static HSSFWorkbook openSampleWorkbook(String sampleFileName, char[] password) {
+        try (InputStream stream = _inst.openResourceAsStream(sampleFileName)){
+            return new HSSFWorkbook(stream, password);
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     /**
      * Writes a spreadsheet to a {@code ByteArrayOutputStream} and reads it back
      * from a {@code ByteArrayInputStream}.<p>

poi/src/test/java/org/apache/poi/hssf/usermodel/TestHSSFWorkbook.java

@@ -1249,6 +1249,16 @@ void testWorkbookCloseClosesInputStream() throws Exception {
         }
     }
 
+    @Test
+    void testPassword() throws Exception {
+        try (HSSFWorkbook wb = HSSFTestDataSamples.openSampleWorkbook(
+                "xor-encryption-abc.xls", "abc".toCharArray())) {
+            HSSFSheet hssfSheet = wb.getSheetAt(0);
+            double a1Value = hssfSheet.getRow(0).getCell(0).getNumericCellValue();
+            assertEquals(1.0, a1Value);
+        }
+    }
+
     private static class WrappedStream extends FilterInputStream {
         private boolean closed;