Changeset 40329 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Mar 2, 2012 4:13:50 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

76594

Message:

Main/Runtime/VBoxManage: SHA256 support comes with OVF 2.0

Location:

trunk/src/VBox/Main/src-server

Files:

• ApplianceImplExport.cpp (modified) (13 diffs)
• ApplianceImplIO.cpp (modified) (40 diffs)
• ApplianceImplImport.cpp (modified) (29 diffs)

trunk/src/VBox/Main/src-server/ApplianceImplExport.cpp

@@ -558 +558 @@
     else if (strFormat == "ovf-1.0")
         ovfF = OVF_1_0;
+    else if (strFormat == "ovf-2.0")
+        ovfF = OVF_2_0;
     else
         return setError(VBOX_E_FILE_ERROR,
                         tr("Invalid format \"%s\" specified"), strFormat.c_str());
+
+    /* as of OVF 2.0 we have to use SHA256 */
+    m->fSha256 = ovfF >= OVF_2_0;
 
     ComObjPtr<Progress> progress;
@@ -658 +663 @@
     xml::ElementNode *pelmRoot = doc.createRootElement("Envelope");
 
-    pelmRoot->setAttribute("ovf:version", (enFormat == OVF_1_0) ? "1.0" : "0.9");
+    pelmRoot->setAttribute("ovf:version", enFormat == OVF_2_0 ? "2.0"
+                                        : enFormat == OVF_1_0 ? "1.0"
+                                        :                       "0.9");
     pelmRoot->setAttribute("xml:lang", "en-US");
 
@@ -1621 +1628 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pShaIo = 0;
     PVDINTERFACEIO pFileIo = 0;
     do
     {
-        pSha1Io = Sha1CreateInterface();
-        if (!pSha1Io)
+        pShaIo = ShaCreateInterface();
+        if (!pShaIo)
         {
             rc = E_OUTOFMEMORY;
@@ -1638 +1645 @@
         }
 
-        SHA1STORAGE storage;
+        SHASTORAGE storage;
         RT_ZERO(storage);
         storage.fCreateDigest = m->fManifest;
+        storage.fSha256 = m->fSha256;
         int vrc = VDInterfaceAdd(&pFileIo->Core, "Appliance::IOFile",
                                  VDINTERFACETYPE_IO, 0, sizeof(VDINTERFACEIO),
@@ -1649 +1657 @@
             break;
         }
-        rc = writeFSImpl(pTask, writeLock, pSha1Io, &storage);
+        rc = writeFSImpl(pTask, writeLock, pShaIo, &storage);
     }while(0);
 
     /* Cleanup */
-    if (pSha1Io)
-        RTMemFree(pSha1Io);
+    if (pShaIo)
+        RTMemFree(pShaIo);
     if (pFileIo)
         RTMemFree(pFileIo);
@@ -1675 +1683 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pShaIo = 0;
     PVDINTERFACEIO pTarIo = 0;
     do
     {
-        pSha1Io = Sha1CreateInterface();
-        if (!pSha1Io)
+        pShaIo = ShaCreateInterface();
+        if (!pShaIo)
         {
             rc = E_OUTOFMEMORY;
@@ -1691 +1699 @@
             break;
         }
-        SHA1STORAGE storage;
+        SHASTORAGE storage;
         RT_ZERO(storage);
         storage.fCreateDigest = m->fManifest;
+        storage.fSha256 = m->fSha256;
         vrc = VDInterfaceAdd(&pTarIo->Core, "Appliance::IOTar",
                              VDINTERFACETYPE_IO, tar, sizeof(VDINTERFACEIO),
@@ -1702 +1711 @@
             break;
         }
-        rc = writeFSImpl(pTask, writeLock, pSha1Io, &storage);
+        rc = writeFSImpl(pTask, writeLock, pShaIo, &storage);
     }while(0);
 
@@ -1708 +1717 @@
 
     /* Cleanup */
-    if (pSha1Io)
-        RTMemFree(pSha1Io);
+    if (pShaIo)
+        RTMemFree(pShaIo);
     if (pTarIo)
         RTMemFree(pTarIo);
@@ -1721 +1730 @@
 }
 
-HRESULT Appliance::writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pIfIo, PSHA1STORAGE pStorage)
+HRESULT Appliance::writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pIfIo, PSHASTORAGE pStorage)
 {
     LogFlowFuncEnter();
@@ -1753 +1762 @@
                                strOvfFile.c_str());
             /* Write the ovf file to disk. */
-            vrc = Sha1WriteBuf(strOvfFile.c_str(), pvBuf, cbSize, pIfIo, pStorage);
+            vrc = ShaWriteBuf(strOvfFile.c_str(), pvBuf, cbSize, pIfIo, pStorage);
             if (RT_FAILURE(vrc))
                 throw setError(VBOX_E_FILE_ERROR,
@@ -1861 +1870 @@
             void *pvBuf;
             size_t cbSize;
-            vrc = RTManifestWriteFilesBuf(&pvBuf, &cbSize, paManifestFiles, fileList.size());
+            vrc = RTManifestWriteFilesBuf(&pvBuf, &cbSize, m->fSha256 ? RTDIGESTTYPE_SHA256 : RTDIGESTTYPE_SHA1,
+                                          paManifestFiles, fileList.size());
             RTMemFree(paManifestFiles);
             if (RT_FAILURE(vrc))
@@ -1870 +1880 @@
             pStorage->fCreateDigest = false;
             /* Write the manifest file to disk. */
-            vrc = Sha1WriteBuf(strMfFilePath.c_str(), pvBuf, cbSize, pIfIo, pStorage);
+            vrc = ShaWriteBuf(strMfFilePath.c_str(), pvBuf, cbSize, pIfIo, pStorage);
             RTMemFree(pvBuf);
             if (RT_FAILURE(vrc))

trunk/src/VBox/Main/src-server/ApplianceImplIO.cpp

@@ -53 +53 @@
 } TARSTORAGEINTERNAL, *PTARSTORAGEINTERNAL;
 
-typedef struct SHA1STORAGEINTERNAL
+typedef struct SHASTORAGEINTERNAL
 {
     /** Completion callback. */
@@ -62 +62 @@
     uint32_t fOpenMode;
     /** Our own storage handle. */
-    PSHA1STORAGE pSha1Storage;
+    PSHASTORAGE pShaStorage;
     /** Circular buffer used for transferring data from/to the worker thread. */
     PRTCIRCBUF pCircBuf;
@@ -77 +77 @@
     /** Event for signaling a finished task of the worker thread. */
     RTSEMEVENT workFinishedEvent;
-    /** SHA1 calculation context. */
-    RTSHA1CONTEXT ctx;
+    /** SHA1/SHA256 calculation context. */
+    union
+    {
+        RTSHA1CONTEXT    Sha1;
+        RTSHA256CONTEXT  Sha256;
+    } ctx;
     /** Write mode only: Memory buffer for writing zeros. */
     void *pvZeroBuf;
@@ -87 +91 @@
 //    uint64_t calls;
 //    uint64_t waits;
-} SHA1STORAGEINTERNAL, *PSHA1STORAGEINTERNAL;
+} SHASTORAGEINTERNAL, *PSHASTORAGEINTERNAL;
 
 /******************************************************************************
@@ -458 +462 @@
 
 /******************************************************************************
- *   Internal: RTSha1 interface
+ *   Internal: RTSha interface
  ******************************************************************************/
 
-DECLCALLBACK(int) sha1CalcWorkerThread(RTTHREAD /* aThread */, void *pvUser)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvUser;
-
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pInt->pSha1Storage->pVDImageIfaces);
+DECLCALLBACK(int) shaCalcWorkerThread(RTTHREAD /* aThread */, void *pvUser)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvUser;
+
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pInt->pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
@@ -526 +530 @@
                         pInt->cbCurFile += cbWritten;
                     }
-                    /* Update the SHA1 context with the next data block. */
+                    /* Update the SHA1/SHA256 context with the next data block. */
                     if (   RT_SUCCESS(rc)
-                        && pInt->pSha1Storage->fCreateDigest)
-                        RTSha1Update(&pInt->ctx, pcBuf, cbAllWritten);
+                        && pInt->pShaStorage->fCreateDigest)
+                    {
+                        if (pInt->pShaStorage->fSha256)
+                            RTSha256Update(&pInt->ctx.Sha256, pcBuf, cbAllWritten);
+                        else
+                            RTSha1Update(&pInt->ctx.Sha1, pcBuf, cbAllWritten);
+                    }
                     /* Mark the block as empty. */
                     RTCircBufReleaseReadBlock(pInt->pCircBuf, cbAllWritten);
@@ -585 +594 @@
                         pInt->cbCurFile += cbRead;
                     }
-                    /* Update the SHA1 context with the next data block. */
+                    /* Update the SHA1/SHA256 context with the next data block. */
                     if (   RT_SUCCESS(rc)
-                        && pInt->pSha1Storage->fCreateDigest)
-                        RTSha1Update(&pInt->ctx, pcBuf, cbAllRead);
+                        && pInt->pShaStorage->fCreateDigest)
+                    {
+                        if (pInt->pShaStorage->fSha256)
+                            RTSha256Update(&pInt->ctx.Sha256, pcBuf, cbAllRead);
+                        else
+                            RTSha1Update(&pInt->ctx.Sha1, pcBuf, cbAllRead);
+                    }
                     /* Mark the block as full. */
                     RTCircBufReleaseWriteBlock(pInt->pCircBuf, cbAllRead);
@@ -614 +628 @@
 }
 
-DECLINLINE(int) sha1SignalManifestThread(PSHA1STORAGEINTERNAL pInt, uint32_t uStatus)
+DECLINLINE(int) shaSignalManifestThread(PSHASTORAGEINTERNAL pInt, uint32_t uStatus)
 {
     ASMAtomicWriteU32(&pInt->u32Status, uStatus);
@@ -620 +634 @@
 }
 
-DECLINLINE(int) sha1WaitForManifestThreadFinished(PSHA1STORAGEINTERNAL pInt)
+DECLINLINE(int) shaWaitForManifestThreadFinished(PSHASTORAGEINTERNAL pInt)
 {
 //    RTPrintf("start\n");
@@ -640 +654 @@
 }
 
-DECLINLINE(int) sha1FlushCurBuf(PSHA1STORAGEINTERNAL pInt)
+DECLINLINE(int) shaFlushCurBuf(PSHASTORAGEINTERNAL pInt)
 {
     int rc = VINF_SUCCESS;
@@ -646 +660 @@
     {
         /* Let the write worker thread start immediately. */
-        rc = sha1SignalManifestThread(pInt, STATUS_WRITE);
+        rc = shaSignalManifestThread(pInt, STATUS_WRITE);
         if (RT_FAILURE(rc))
             return rc;
 
         /* Wait until the write worker thread has finished. */
-        rc = sha1WaitForManifestThreadFinished(pInt);
+        rc = shaWaitForManifestThreadFinished(pInt);
     }
 
@@ -657 +671 @@
 }
 
-static int sha1OpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
+static int shaOpenCallback(void *pvUser, const char *pszLocation, uint32_t fOpen,
                               PFNVDCOMPLETED pfnCompleted, void **ppInt)
 {
@@ -667 +681 @@
     AssertReturn((fOpen & RTFILE_O_READWRITE) != RTFILE_O_READWRITE, VERR_INVALID_PARAMETER); /* No read/write allowed */
 
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     DEBUG_PRINT_FLOW();
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)RTMemAllocZ(sizeof(SHA1STORAGEINTERNAL));
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)RTMemAllocZ(sizeof(SHASTORAGEINTERNAL));
     if (!pInt)
         return VERR_NO_MEMORY;
@@ -681 +695 @@
     {
         pInt->pfnCompleted = pfnCompleted;
-        pInt->pSha1Storage = pSha1Storage;
+        pInt->pShaStorage  = pShaStorage;
         pInt->fEOF         = false;
         pInt->fOpenMode    = fOpen;
@@ -716 +730 @@
             break;
         /* Create the worker thread. */
-        rc = RTThreadCreate(&pInt->pWorkerThread, sha1CalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, RTTHREADFLAGS_WAITABLE, "SHA1-Worker");
+        rc = RTThreadCreate(&pInt->pWorkerThread, shaCalcWorkerThread, pInt, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, RTTHREADFLAGS_WAITABLE, "SHA-Worker");
         if (RT_FAILURE(rc))
             break;
 
-        if (pSha1Storage->fCreateDigest)
-            /* Create a SHA1 context the worker thread will work with. */
-            RTSha1Init(&pInt->ctx);
+        if (pShaStorage->fCreateDigest)
+        {
+            /* Create a SHA1/SHA256 context the worker thread will work with. */
+            if (pShaStorage->fSha256)
+                RTSha256Init(&pInt->ctx.Sha256);
+            else
+                RTSha1Init(&pInt->ctx.Sha1);
+        }
 
         /* Open the file. */
@@ -733 +752 @@
         {
             /* Immediately let the worker thread start the reading. */
-            rc = sha1SignalManifestThread(pInt, STATUS_READ);
+            rc = shaSignalManifestThread(pInt, STATUS_READ);
         }
     }
@@ -742 +761 @@
         if (pInt->pWorkerThread)
         {
-            sha1SignalManifestThread(pInt, STATUS_END);
+            shaSignalManifestThread(pInt, STATUS_END);
             RTThreadWait(pInt->pWorkerThread, RT_INDEFINITE_WAIT, 0);
         }
@@ -761 +780 @@
 }
 
-static int sha1CloseCallback(void *pvUser, void *pvStorage)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaCloseCallback(void *pvUser, void *pvStorage)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
 
     DEBUG_PRINT_FLOW();
@@ -778 +797 @@
 
     /* Make sure all pending writes are flushed */
-    rc = sha1FlushCurBuf(pInt);
+    rc = shaFlushCurBuf(pInt);
 
     if (pInt->pWorkerThread)
     {
         /* Signal the worker thread to end himself */
-        rc = sha1SignalManifestThread(pInt, STATUS_END);
+        rc = shaSignalManifestThread(pInt, STATUS_END);
         /* Worker thread stopped? */
         rc = RTThreadWait(pInt->pWorkerThread, RT_INDEFINITE_WAIT, 0);
@@ -789 +808 @@
 
     if (   RT_SUCCESS(rc)
-        && pSha1Storage->fCreateDigest)
-    {
-        /* Finally calculate & format the SHA1 sum */
-        unsigned char auchDig[RTSHA1_HASH_SIZE];
+        && pShaStorage->fCreateDigest)
+    {
+        /* Finally calculate & format the SHA1/SHA256 sum */
+        unsigned char auchDig[RTSHA256_HASH_SIZE];
         char *pszDigest;
-        RTSha1Final(&pInt->ctx, auchDig);
-        rc = RTStrAllocEx(&pszDigest, RTSHA1_DIGEST_LEN + 1);
+        size_t cbDigest;
+        if (pShaStorage->fSha256)
+        {
+            RTSha256Final(&pInt->ctx.Sha256, auchDig);
+            cbDigest = RTSHA256_DIGEST_LEN;
+        }
+        else
+        {
+            RTSha1Final(&pInt->ctx.Sha1, auchDig);
+            cbDigest = RTSHA1_DIGEST_LEN;
+        }
+        rc = RTStrAllocEx(&pszDigest, cbDigest + 1);
         if (RT_SUCCESS(rc))
         {
-            rc = RTSha1ToString(auchDig, pszDigest, RTSHA1_DIGEST_LEN + 1);
+            if (pShaStorage->fSha256)
+                rc = RTSha256ToString(auchDig, pszDigest, cbDigest + 1);
+            else
+                rc = RTSha1ToString(auchDig, pszDigest, cbDigest + 1);
             if (RT_SUCCESS(rc))
-                pSha1Storage->strDigest = pszDigest;
+                pShaStorage->strDigest = pszDigest;
             RTStrFree(pszDigest);
         }
@@ -824 +856 @@
 }
 
-static int sha1DeleteCallback(void *pvUser, const char *pcszFilename)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaDeleteCallback(void *pvUser, const char *pcszFilename)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
@@ -838 +870 @@
 }
 
-static int sha1MoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaMoveCallback(void *pvUser, const char *pcszSrc, const char *pcszDst, unsigned fMove)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
@@ -853 +885 @@
 }
 
-static int sha1GetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaGetFreeSpaceCallback(void *pvUser, const char *pcszFilename, int64_t *pcbFreeSpace)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
@@ -867 +899 @@
 }
 
-static int sha1GetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaGetModificationTimeCallback(void *pvUser, const char *pcszFilename, PRTTIMESPEC pModificationTime)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
@@ -882 +914 @@
 
 
-static int sha1GetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaGetSizeCallback(void *pvUser, void *pvStorage, uint64_t *pcbSize)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
 
     DEBUG_PRINT_FLOW();
@@ -906 +938 @@
 }
 
-static int sha1SetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaSetSizeCallback(void *pvUser, void *pvStorage, uint64_t cbSize)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
 
     DEBUG_PRINT_FLOW();
@@ -923 +955 @@
 }
 
-static int sha1WriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
+static int shaWriteSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
                                  const void *pvBuf, size_t cbWrite, size_t *pcbWritten)
 {
@@ -930 +962 @@
     AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
 
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
 
     DEBUG_PRINT_FLOW();
@@ -956 +988 @@
             size_t cbToWrite = RT_MIN(pInt->cbZeroBuf, cbSize - cbAllWritten);
             size_t cbWritten = 0;
-            rc = sha1WriteSyncCallback(pvUser, pvStorage, pInt->cbCurAll,
-                                       pInt->pvZeroBuf, cbToWrite, &cbWritten);
+            rc = shaWriteSyncCallback(pvUser, pvStorage, pInt->cbCurAll,
+                                      pInt->pvZeroBuf, cbToWrite, &cbWritten);
             if (RT_FAILURE(rc))
                 break;
@@ -981 +1013 @@
         if ((cbWrite - cbAllWritten) > cbAvail)
         {
-            rc = sha1SignalManifestThread(pInt, STATUS_WRITE);
+            rc = shaSignalManifestThread(pInt, STATUS_WRITE);
             if(RT_FAILURE(rc))
                 break;
@@ -987 +1019 @@
             if (cbAvail == 0)
             {
-                rc = sha1WaitForManifestThreadFinished(pInt);
+                rc = shaWaitForManifestThreadFinished(pInt);
                 if (RT_FAILURE(rc))
                     break;
@@ -1013 +1045 @@
     if (   RT_SUCCESS(rc)
            && RTCircBufUsed(pInt->pCircBuf) >= (RTCircBufSize(pInt->pCircBuf) / 2))
-        rc = sha1SignalManifestThread(pInt, STATUS_WRITE);
+        rc = shaSignalManifestThread(pInt, STATUS_WRITE);
 
     return rc;
 }
 
-static int sha1ReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
-                                  void *pvBuf, size_t cbRead, size_t *pcbRead)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaReadSyncCallback(void *pvUser, void *pvStorage, uint64_t uOffset,
+                               void *pvBuf, size_t cbRead, size_t *pcbRead)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
 //    DEBUG_PRINT_FLOW();
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
 
     int rc = VINF_SUCCESS;
@@ -1039 +1071 @@
 
     /* Check if we jump forward in the file. If so we have to read the
-     * remaining stuff in the gap anyway (SHA1; streaming). */
+     * remaining stuff in the gap anyway (SHA1/SHA256; streaming). */
     if (pInt->cbCurAll < uOffset)
     {
-        rc = sha1ReadSyncCallback(pvUser, pvStorage, pInt->cbCurAll, 0,
-                                  (size_t)(uOffset - pInt->cbCurAll), 0);
+        rc = shaReadSyncCallback(pvUser, pvStorage, pInt->cbCurAll, 0,
+                                 (size_t)(uOffset - pInt->cbCurAll), 0);
         if (RT_FAILURE(rc))
             return rc;
@@ -1066 +1098 @@
         if ((cbRead - cbAllRead) > cbAvail)
         {
-            rc = sha1SignalManifestThread(pInt, STATUS_READ);
+            rc = shaSignalManifestThread(pInt, STATUS_READ);
             if(RT_FAILURE(rc))
                 break;
@@ -1072 +1104 @@
             if (cbAvail == 0)
             {
-                rc = sha1WaitForManifestThreadFinished(pInt);
+                rc = shaWaitForManifestThreadFinished(pInt);
                 if (RT_FAILURE(rc))
                     break;
@@ -1103 +1135 @@
     if (   RT_SUCCESS(rc)
         && RTCircBufFree(pInt->pCircBuf) >= (RTCircBufSize(pInt->pCircBuf) / 2))
-        rc = sha1SignalManifestThread(pInt, STATUS_READ);
+        rc = shaSignalManifestThread(pInt, STATUS_READ);
 
     return rc;
 }
 
-static int sha1FlushSyncCallback(void *pvUser, void *pvStorage)
-{
-    /* Validate input. */
-    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
-
-    PSHA1STORAGE pSha1Storage = (PSHA1STORAGE)pvUser;
-    PVDINTERFACEIO pIfIo = VDIfIoGet(pSha1Storage->pVDImageIfaces);
+static int shaFlushSyncCallback(void *pvUser, void *pvStorage)
+{
+    /* Validate input. */
+    AssertPtrReturn(pvUser, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvStorage, VERR_INVALID_POINTER);
+
+    PSHASTORAGE pShaStorage = (PSHASTORAGE)pvUser;
+    PVDINTERFACEIO pIfIo = VDIfIoGet(pShaStorage->pVDImageIfaces);
     AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
 
     DEBUG_PRINT_FLOW();
 
-    PSHA1STORAGEINTERNAL pInt = (PSHA1STORAGEINTERNAL)pvStorage;
+    PSHASTORAGEINTERNAL pInt = (PSHASTORAGEINTERNAL)pvStorage;
 
     /* Check if there is still something in the buffer. If yes, flush it. */
-    int rc = sha1FlushCurBuf(pInt);
+    int rc = shaFlushCurBuf(pInt);
     if (RT_FAILURE(rc))
         return rc;
@@ -1134 +1166 @@
  ******************************************************************************/
 
-PVDINTERFACEIO Sha1CreateInterface()
+PVDINTERFACEIO ShaCreateInterface()
 {
     PVDINTERFACEIO pCallbacks = (PVDINTERFACEIO)RTMemAllocZ(sizeof(VDINTERFACEIO));
@@ -1140 +1172 @@
         return NULL;
 
-    pCallbacks->pfnOpen                = sha1OpenCallback;
-    pCallbacks->pfnClose               = sha1CloseCallback;
-    pCallbacks->pfnDelete              = sha1DeleteCallback;
-    pCallbacks->pfnMove                = sha1MoveCallback;
-    pCallbacks->pfnGetFreeSpace        = sha1GetFreeSpaceCallback;
-    pCallbacks->pfnGetModificationTime = sha1GetModificationTimeCallback;
-    pCallbacks->pfnGetSize             = sha1GetSizeCallback;
-    pCallbacks->pfnSetSize             = sha1SetSizeCallback;
-    pCallbacks->pfnReadSync            = sha1ReadSyncCallback;
-    pCallbacks->pfnWriteSync           = sha1WriteSyncCallback;
-    pCallbacks->pfnFlushSync           = sha1FlushSyncCallback;
+    pCallbacks->pfnOpen                = shaOpenCallback;
+    pCallbacks->pfnClose               = shaCloseCallback;
+    pCallbacks->pfnDelete              = shaDeleteCallback;
+    pCallbacks->pfnMove                = shaMoveCallback;
+    pCallbacks->pfnGetFreeSpace        = shaGetFreeSpaceCallback;
+    pCallbacks->pfnGetModificationTime = shaGetModificationTimeCallback;
+    pCallbacks->pfnGetSize             = shaGetSizeCallback;
+    pCallbacks->pfnSetSize             = shaSetSizeCallback;
+    pCallbacks->pfnReadSync            = shaReadSyncCallback;
+    pCallbacks->pfnWriteSync           = shaWriteSyncCallback;
+    pCallbacks->pfnFlushSync           = shaFlushSyncCallback;
 
     return pCallbacks;
@@ -1197 +1229 @@
 }
 
-int Sha1ReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pIfIo, void *pvUser)
+int ShaReadBuf(const char *pcszFilename, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pIfIo, void *pvUser)
 {
     /* Validate input. */
@@ -1263 +1295 @@
 }
 
-int Sha1WriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pIfIo, void *pvUser)
+int ShaWriteBuf(const char *pcszFilename, void *pvBuf, size_t cbSize, PVDINTERFACEIO pIfIo, void *pvUser)
 {
     /* Validate input. */

trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

@@ -818 +818 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pShaIo = 0;
     PVDINTERFACEIO pFileIo = 0;
     do
     {
-        pSha1Io = Sha1CreateInterface();
-        if (!pSha1Io)
+        pShaIo = ShaCreateInterface();
+        if (!pShaIo)
         {
             rc = E_OUTOFMEMORY;
@@ -834 +834 @@
             break;
         }
-        SHA1STORAGE storage;
+        SHASTORAGE storage;
         RT_ZERO(storage);
         int vrc = VDInterfaceAdd(&pFileIo->Core, "Appliance::IOFile",
@@ -845 +845 @@
         }
 
-        rc = readFSImpl(pTask, pTask->locInfo.strPath, pSha1Io, &storage);
+        rc = readFSImpl(pTask, pTask->locInfo.strPath, pShaIo, &storage);
     }while(0);
 
     /* Cleanup */
-    if (pSha1Io)
-        RTMemFree(pSha1Io);
+    if (pShaIo)
+        RTMemFree(pShaIo);
     if (pFileIo)
         RTMemFree(pFileIo);
@@ -873 +873 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pShaIo = 0;
     PVDINTERFACEIO pTarIo = 0;
     char *pszFilename = 0;
@@ -884 +884 @@
             break;
         }
-        pSha1Io = Sha1CreateInterface();
-        if (!pSha1Io)
+        pShaIo = ShaCreateInterface();
+        if (!pShaIo)
         {
             rc = E_OUTOFMEMORY;
@@ -896 +896 @@
             break;
         }
-        SHA1STORAGE storage;
+        SHASTORAGE storage;
         RT_ZERO(storage);
         vrc = VDInterfaceAdd(&pTarIo->Core, "Appliance::IOTar",
@@ -906 +906 @@
             break;
         }
-        rc = readFSImpl(pTask, pszFilename, pSha1Io, &storage);
+        rc = readFSImpl(pTask, pszFilename, pShaIo, &storage);
     }while(0);
 
@@ -914 +914 @@
     if (pszFilename)
         RTMemFree(pszFilename);
-    if (pSha1Io)
-        RTMemFree(pSha1Io);
+    if (pShaIo)
+        RTMemFree(pShaIo);
     if (pTarIo)
         RTMemFree(pTarIo);
@@ -925 +925 @@
 }
 
-HRESULT Appliance::readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pIfIo, PSHA1STORAGE pStorage)
+HRESULT Appliance::readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pIfIo, PSHASTORAGE pStorage)
 {
     LogFlowFuncEnter();
@@ -938 +938 @@
         /* Read the OVF into a memory buffer */
         size_t cbSize = 0;
-        int vrc = Sha1ReadBuf(strFilename.c_str(), &pvTmpBuf, &cbSize, pIfIo, pStorage);
+        int vrc = ShaReadBuf(strFilename.c_str(), &pvTmpBuf, &cbSize, pIfIo, pStorage);
         if (   RT_FAILURE(vrc)
             || !pvTmpBuf)
@@ -944 +944 @@
                            tr("Could not read OVF file '%s' (%Rrc)"),
                            RTPathFilename(strFilename.c_str()), vrc);
-        /* Copy the SHA1 sum of the OVF file for later validation */
-        m->strOVFSHA1Digest = pStorage->strDigest;
+        /* Copy the SHA1/SHA256 sum of the OVF file for later validation */
+        m->strOVFSHADigest = pStorage->strDigest;
         /* Read & parse the XML structure of the OVF file */
         m->pReader = new ovf::OVFReader(pvTmpBuf, cbSize, pTask->locInfo.strPath);
@@ -1233 +1233 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pShaIo = 0;
     PVDINTERFACEIO pFileIo = 0;
     void *pvMfBuf = 0;
@@ -1240 +1240 @@
     {
         /* Create the necessary file access interfaces. */
-        pSha1Io = Sha1CreateInterface();
-        if (!pSha1Io)
+        pShaIo = ShaCreateInterface();
+        if (!pShaIo)
             throw setError(E_OUTOFMEMORY);
         pFileIo = FileCreateInterface();
@@ -1247 +1247 @@
             throw setError(E_OUTOFMEMORY);
 
-        SHA1STORAGE storage;
+        SHASTORAGE storage;
         RT_ZERO(storage);
         storage.fCreateDigest = true;
@@ -1263 +1263 @@
         storage.fCreateDigest = RTFileExists(strMfFile.c_str());
         /* Now import the appliance. */
-        importMachines(stack, pSha1Io, &storage);
+        importMachines(stack, pShaIo, &storage);
         /* Read & verify the manifest file, if there is one. */
         if (storage.fCreateDigest)
         {
             /* Add the ovf file to the digest list. */
-            stack.llSrcDisksDigest.push_front(STRPAIR(pTask->locInfo.strPath, m->strOVFSHA1Digest));
-            rc = readManifestFile(strMfFile, &pvMfBuf, &cbMfSize, pSha1Io, &storage);
+            stack.llSrcDisksDigest.push_front(STRPAIR(pTask->locInfo.strPath, m->strOVFSHADigest));
+            rc = readManifestFile(strMfFile, &pvMfBuf, &cbMfSize, pShaIo, &storage);
             if (FAILED(rc)) throw rc;
             rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
@@ -1284 +1284 @@
     if (pvMfBuf)
         RTMemFree(pvMfBuf);
-    if (pSha1Io)
-        RTMemFree(pSha1Io);
+    if (pShaIo)
+        RTMemFree(pShaIo);
     if (pFileIo)
         RTMemFree(pFileIo);
@@ -1308 +1308 @@
     HRESULT rc = S_OK;
 
-    PVDINTERFACEIO pSha1Io = 0;
+    PVDINTERFACEIO pShaIo = 0;
     PVDINTERFACEIO pTarIo = 0;
     char *pszFilename = 0;
@@ -1316 +1316 @@
     {
         /* Create the necessary file access interfaces. */
-        pSha1Io = Sha1CreateInterface();
-        if (!pSha1Io)
+        pShaIo = ShaCreateInterface();
+        if (!pShaIo)
             throw setError(E_OUTOFMEMORY);
         pTarIo = TarCreateInterface();
@@ -1323 +1323 @@
             throw setError(E_OUTOFMEMORY);
 
-        SHA1STORAGE storage;
+        SHASTORAGE storage;
         RT_ZERO(storage);
         vrc = VDInterfaceAdd(&pTarIo->Core, "Appliance::IOTar",
@@ -1345 +1345 @@
                            tr("Seeking within the archive failed (%Rrc)"), vrc);
 
-        PVDINTERFACEIO pCallbacks = pSha1Io;
-        PSHA1STORAGE pStorage = &storage;
+        PVDINTERFACEIO pCallbacks = pShaIo;
+        PSHASTORAGE pStorage = &storage;
 
         /* We always need to create the digest, cause we didn't know if there
@@ -1382 +1382 @@
         {
             /* Add the ovf file to the digest list. */
-            stack.llSrcDisksDigest.push_front(STRPAIR(Utf8Str(pszFilename).stripExt().append(".ovf"), m->strOVFSHA1Digest));
+            stack.llSrcDisksDigest.push_front(STRPAIR(Utf8Str(pszFilename).stripExt().append(".ovf"), m->strOVFSHADigest));
             rc = verifyManifestFile(strMfFile, stack, pvMfBuf, cbMfSize);
             if (FAILED(rc)) throw rc;
@@ -1400 +1400 @@
     if (pvMfBuf)
         RTMemFree(pvMfBuf);
-    if (pSha1Io)
-        RTMemFree(pSha1Io);
+    if (pShaIo)
+        RTMemFree(pShaIo);
     if (pTarIo)
         RTMemFree(pTarIo);
@@ -1604 +1604 @@
 #endif /* VBOX_WITH_S3 */
 
-HRESULT Appliance::readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
+HRESULT Appliance::readManifestFile(const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage)
 {
     HRESULT rc = S_OK;
@@ -1610 +1610 @@
     bool fOldDigest = pStorage->fCreateDigest;
     pStorage->fCreateDigest = false; /* No digest for the manifest file */
-    int vrc = Sha1ReadBuf(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
+    int vrc = ShaReadBuf(strFile.c_str(), ppvBuf, pcbSize, pCallbacks, pStorage);
     if (   RT_FAILURE(vrc)
         && vrc != VERR_FILE_NOT_FOUND)
@@ -1621 +1621 @@
 }
 
-HRESULT Appliance::readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHA1STORAGE pStorage)
+HRESULT Appliance::readTarManifestFile(RTTAR tar, const Utf8Str &strFile, void **ppvBuf, size_t *pcbSize, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage)
 {
     HRESULT rc = S_OK;
@@ -1795 +1795 @@
                                    ImportStack &stack,
                                    PVDINTERFACEIO pCallbacks,
-                                   PSHA1STORAGE pStorage)
+                                   PSHASTORAGE pStorage)
 {
     ComObjPtr<Progress> pProgress;
@@ -1934 +1934 @@
                                      ImportStack &stack,
                                      PVDINTERFACEIO pCallbacks,
-                                     PSHA1STORAGE pStorage)
+                                     PSHASTORAGE pStorage)
 {
     HRESULT rc;
@@ -2502 +2502 @@
                                   ImportStack &stack,
                                   PVDINTERFACEIO pCallbacks,
-                                  PSHA1STORAGE pStorage)
+                                  PSHASTORAGE pStorage)
 {
     Assert(vsdescThis->m->pConfig);
@@ -2814 +2814 @@
 void Appliance::importMachines(ImportStack &stack,
                                PVDINTERFACEIO pCallbacks,
-                               PSHA1STORAGE pStorage)
+                               PSHASTORAGE pStorage)
 {
     HRESULT rc = S_OK;