예제 #1
0
  public int ChangeStreamPass(
      XStorage xStorage, String sStreamName, byte[] pOldPass, byte[] pNewPass) {
    // open substream element
    XStream xSubStream = null;
    try {
      Object oSubStream =
          xStorage.openEncryptedStreamElement(
              sStreamName, ElementModes.WRITE, new String(pOldPass));
      xSubStream = UnoRuntime.queryInterface(XStream.class, oSubStream);
      if (xSubStream == null) {
        Error("Can't open substream '" + sStreamName + "'!");
        return 0;
      }
    } catch (Exception e) {
      Error("Can't open substream '" + sStreamName + "', exception : " + e + "!");
      return 0;
    }

    // change the password for the stream
    XEncryptionProtectedSource xStreamEncryption =
        UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xSubStream);

    if (xStreamEncryption == null) {
      Message(
          "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!");
      return -1;
    }

    try {
      xStreamEncryption.setEncryptionPassword(new String(pNewPass));
    } catch (Exception e) {
      Error("Can't change encryption key of the substream '" + sStreamName + "', exception:" + e);
      return 0;
    }

    // free the stream resources, garbage collector may remove the object too late
    XComponent xComponent = UnoRuntime.queryInterface(XComponent.class, xSubStream);
    if (xComponent == null) {
      Error("Can't get XComponent implementation from substream '" + sStreamName + "'!");
      return 0;
    }
    xComponent.dispose();

    return 1;
  }
예제 #2
0
  public int ChangeStreamPassH(
      XStorage xStorage, String sPath, String sOldPass, String sNewPass, boolean bCommit) {
    // open substream element
    XHierarchicalStorageAccess xHStorage =
        (XHierarchicalStorageAccess)
            UnoRuntime.queryInterface(XHierarchicalStorageAccess.class, xStorage);
    if (xHStorage == null) {
      Error("The storage does not support hierarchical access!");
      return 0;
    }

    XStream xSubStream = null;
    try {
      Object oSubStream =
          xHStorage.openEncryptedStreamElementByHierarchicalName(
              sPath, ElementModes.WRITE, sOldPass);
      xSubStream = (XStream) UnoRuntime.queryInterface(XStream.class, oSubStream);
      if (xSubStream == null) {
        Error("Can't open encrypted substream '" + sPath + "'!");
        return 0;
      }
    } catch (Exception e) {
      Error("Can't open encrypted substream '" + sPath + "', exception : " + e + "!");
      return 0;
    }

    // change the password for the stream
    XEncryptionProtectedSource xStreamEncryption =
        (XEncryptionProtectedSource)
            UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xSubStream);

    if (xStreamEncryption == null) {
      Message(
          "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!");
      return -1;
    }

    try {
      xStreamEncryption.setEncryptionPassword(sNewPass);
    } catch (Exception e) {
      Error("Can't change encryption key of the substream '" + sPath + "', exception:" + e);
      return 0;
    }

    XTransactedObject xTransact =
        (XTransactedObject) UnoRuntime.queryInterface(XTransactedObject.class, xSubStream);
    if (xTransact == null) {
      Error("Substream '" + sPath + "', stream opened for writing must be transacted!");
      return 0;
    }

    if (bCommit) {
      try {
        xTransact.commit();
      } catch (Exception e) {
        Error(
            "Can't commit storage after substream '" + sPath + "' change, exception : " + e + "!");
        return 0;
      }
    }

    // free the stream resources, garbage collector may remove the object too late
    if (!disposeStream(xSubStream, sPath)) return 0;

    return 1;
  }
예제 #3
0
  public boolean testForPath(String aStreamPrefix) {
    try {
      String aSubStream1Path = aStreamPrefix + "SubStream1";
      String aSubStream2Path = aStreamPrefix + "SubStream2";
      String aSubStream3Path = aStreamPrefix + "SubStream3";
      String aSubStream4Path = aStreamPrefix + "SubStream4";

      String sTempFileURL = m_aTestHelper.CreateTempFile(m_xMSF);
      if (sTempFileURL == null || sTempFileURL == "") {
        m_aTestHelper.Error("No valid temporary file was created!");
        return false;
      }

      // create temporary storage based on a previously created temporary file
      Object pArgs[] = new Object[2];
      pArgs[0] = (Object) sTempFileURL;
      pArgs[1] = new Integer(ElementModes.WRITE);

      Object oTempFileStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
      XStorage xTempFileStorage =
          (XStorage) UnoRuntime.queryInterface(XStorage.class, oTempFileStorage);
      if (xTempFileStorage == null) {
        m_aTestHelper.Error("Can't create storage based on temporary file!");
        return false;
      }

      // set the global password for the root storage
      XEncryptionProtectedSource xTempStorageEncryption =
          (XEncryptionProtectedSource)
              UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xTempFileStorage);

      if (xTempStorageEncryption == null) {
        m_aTestHelper.Message(
            "Optional interface XEncryptionProtectedSource is not implemented, feature can not be tested!");
        return true;
      }

      String sPass1 = "12345";
      String sPass2 = "54321";

      try {
        xTempStorageEncryption.setEncryptionPassword(sPass1);
      } catch (Exception e) {
        m_aTestHelper.Error("Can't set a common encryption key for the storage, exception:" + e);
        return false;
      }

      byte pBytes1[] = {1, 1, 1, 1, 1};
      byte pBytes2[] = {2, 2, 2, 2, 2};

      // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and commit
      if (!m_aTestHelper.WBToSubstrOfEncrH(
          xTempFileStorage, aSubStream1Path, "MediaType1", true, pBytes1, true, true)) return false;

      // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and commit
      if (!m_aTestHelper.WriteBytesToEncrStreamH(
          xTempFileStorage, aSubStream2Path, "MediaType2", false, pBytes2, sPass2, true))
        return false;

      // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and commit
      if (!m_aTestHelper.WriteBytesToEncrStreamH(
          xTempFileStorage, aSubStream3Path, "MediaType3", false, pBytes2, sPass2, true))
        return false;

      // open a new substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and dont commit
      if (!m_aTestHelper.WBToSubstrOfEncrH(
          xTempFileStorage, aSubStream4Path, "MediaType2", true, pBytes1, true, false))
        return false;

      // set "MediaType" property for storages and check that "IsRoot" and "OpenMode" properties are
      // set correctly
      if (!m_aTestHelper.setStorageTypeAndCheckProps(
          xTempFileStorage, "MediaType3", true, ElementModes.WRITE)) return false;

      // commit the root storage so the contents must be stored now
      if (!m_aTestHelper.commitStorage(xTempFileStorage)) return false;

      // dispose used storages to free resources
      if (!m_aTestHelper.disposeStorage(xTempFileStorage)) return false;

      // ================================================
      // now reopen the storage,
      // check all the written and copied information
      // and change it
      // ================================================

      // the temporary file must not be locked any more after storage disposing
      oTempFileStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
      xTempFileStorage = (XStorage) UnoRuntime.queryInterface(XStorage.class, oTempFileStorage);
      if (xTempFileStorage == null) {
        m_aTestHelper.Error("Can't create storage based on temporary file!");
        return false;
      }

      // set the global password for the root storage
      xTempStorageEncryption =
          (XEncryptionProtectedSource)
              UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xTempFileStorage);

      if (xTempStorageEncryption == null) {
        m_aTestHelper.Error("XEncryptionProtectedSource is supported, but can not be retrieved!");
        return false;
      }

      try {
        xTempStorageEncryption.setEncryptionPassword(sPass2);
      } catch (Exception e) {
        m_aTestHelper.Error("Can't set a common encryption key for the storage, exception:" + e);
        return false;
      }

      if (!m_aTestHelper.checkStorageProperties(
          xTempFileStorage, "MediaType3", true, ElementModes.WRITE)) return false;

      if (!m_aTestHelper.checkEncrStreamH(
          xTempFileStorage, aSubStream1Path, "MediaType1", pBytes1, sPass1)) return false;

      if (!m_aTestHelper.checkStreamH(
          xTempFileStorage, aSubStream2Path, "MediaType2", true, pBytes2)) return false;

      if (!m_aTestHelper.checkStreamH(
          xTempFileStorage, aSubStream3Path, "MediaType3", true, pBytes2)) return false;

      if (!m_aTestHelper.cantOpenEncrStreamH(
          xTempFileStorage, aSubStream4Path, ElementModes.READ, sPass1)) return false;

      // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and commit
      if (!m_aTestHelper.WriteBytesToEncrStreamH(
          xTempFileStorage, aSubStream1Path, "MediaType4", true, pBytes2, sPass1, true))
        return false;

      // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and don't commit
      if (!m_aTestHelper.WriteBytesToStreamH(
          xTempFileStorage, aSubStream2Path, "MediaType5", true, pBytes1, true)) return false;

      // change the password of the existing stream
      if (m_aTestHelper.ChangeStreamPassH(xTempFileStorage, aSubStream2Path, sPass2, sPass1, true)
          != 1) return false;

      // open existing substream hierarchically, set "MediaType" and "Compressed" properties to it,
      // write some bytes
      // and don't commit
      if (!m_aTestHelper.WriteBytesToStreamH(
          xTempFileStorage, aSubStream3Path, "MediaType5", true, pBytes1, false)) return false;

      // commit the root storage so the contents must be stored now
      if (!m_aTestHelper.commitStorage(xTempFileStorage)) return false;

      // dispose used storages to free resources
      if (!m_aTestHelper.disposeStorage(xTempFileStorage)) return false;

      // ================================================
      // now reopen the storage,
      // check all the written information
      // ================================================

      // the temporary file must not be locked any more after storage disposing
      pArgs[1] = new Integer(ElementModes.READ);
      Object oResultStorage = m_xStorageFactory.createInstanceWithArguments(pArgs);
      XStorage xResultStorage =
          (XStorage) UnoRuntime.queryInterface(XStorage.class, oResultStorage);
      if (xResultStorage == null) {
        m_aTestHelper.Error("Can't reopen storage based on temporary file!");
        return false;
      }

      // set the global password for the root storage
      xTempStorageEncryption =
          (XEncryptionProtectedSource)
              UnoRuntime.queryInterface(XEncryptionProtectedSource.class, xResultStorage);

      if (xTempStorageEncryption == null) {
        m_aTestHelper.Error("XEncryptionProtectedSource is supported, but can not be retrieved!");
        return false;
      }

      try {
        xTempStorageEncryption.setEncryptionPassword(sPass1);
      } catch (Exception e) {
        m_aTestHelper.Error("Can't set a common encryption key for the storage, exception:" + e);
        return false;
      }

      if (!m_aTestHelper.checkStorageProperties(
          xResultStorage, "MediaType3", true, ElementModes.READ)) return false;

      if (!m_aTestHelper.checkStreamH(xResultStorage, aSubStream1Path, "MediaType4", true, pBytes2))
        return false;

      if (!m_aTestHelper.checkStreamH(xResultStorage, aSubStream2Path, "MediaType5", true, pBytes1))
        return false;

      if (!m_aTestHelper.checkEncrStreamH(
          xResultStorage, aSubStream3Path, "MediaType3", pBytes2, sPass2)) return false;

      // dispose used storages to free resources
      if (!m_aTestHelper.disposeStorage(xResultStorage)) return false;

      return true;
    } catch (Exception e) {
      m_aTestHelper.Error("Exception: " + e);
      return false;
    }
  }