pgpdiskhighlevelutils.cpp

vc环境下的pgp源码

		derr = InternalChangePassphrase(userInfo, &fileHeader->salt, 
			oldPassphrase, newPassphrase);
	}

	// Set the modified header
	if (derr.IsntError())
	{
		derr = WritePGPdiskFileMainHeader(path, fileHeader);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return derr;
}

// RemovePassphrase removes an alternate passphrase from the specified
// PGPdisk.

DualErr
RemovePassphrase(LPCSTR path, SecureString *passphrase)
{
	DualErr				derr;
	PGPBoolean			didRemove, readHeader;
	PGPdiskFileHeader	*fileHeader;

	didRemove = readHeader = FALSE;

	pgpAssertStrValid(path);
	pgpAssertAddrValid(passphrase, SecureString);

	// Read in the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	// Remove the passphrase if we can find it.
	if (derr.IsntError())
	{
		for (PGPUInt16 index = 1; index <= kMaxAlternatePassphrases; ++index)
		{
			PassphraseKey *userInfo;

			userInfo = (PassphraseKey *) 
				GetPassphraseKeyPtr(fileHeader, index);

			// Is this passphrase in use?
			if (userInfo->inUse)
			{
				DualErr passMatches;

				passMatches = VerifyPassphraseKey(userInfo, 
					&fileHeader->salt, passphrase);

				// Does it match the passphrase we wish to remove?
				if (passMatches.IsntError())
				{
					// Update the fileheader.
					if (derr.IsntError())
					{
						pgpClearMemory(userInfo, sizeof(PassphraseKey));
						userInfo->inUse	= FALSE;

						derr = WritePGPdiskFileMainHeader(path, fileHeader);
						didRemove = derr.IsntError();
						break;
					}
				}
			}
		}
	}

	if (derr.IsntError())
	{
		if (!didRemove)
			derr = DualErr(kPGDMinorError_IncorrectPassphrase);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return derr;
}

// RemoveAlternatePassphrases removes all alternate passphrases from the 
// specified PGPdisk.

DualErr
RemoveAlternatePassphrases(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			readHeader	= FALSE;
	PGPdiskFileHeader	*fileHeader;

	pgpAssertStrValid(path);

	// Read in the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	// Remove all alternate passphrases.
	if (derr.IsntError())
	{
		for (PGPUInt16 index = 1; index <= kMaxAlternatePassphrases; ++index)
		{
			PassphraseKey *userInfo;

			userInfo = 
				(PassphraseKey *) GetPassphraseKeyPtr(fileHeader, index);

			// This clears the inUse flag as well
			pgpClearMemory(userInfo, sizeof(PassphraseKey));
			userInfo->inUse	= FALSE;
		}

		derr = WritePGPdiskFileMainHeader(path, fileHeader);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return derr;
}


//////////////////////////////////
// Miscellaneous utility functions
//////////////////////////////////

// IsPGPdiskNotEncrypted returns TRUE if the specified PGPdisk was created
// without encryption, FALSE otherwise.

PGPBoolean 
IsPGPdiskNotEncrypted(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			isNotEncrypted, readHeader;
	PGPdiskFileHeader	*fileHeader;

	isNotEncrypted = readHeader = FALSE;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	// Determine if encryption was used.
	if (derr.IsntError())
	{
		isNotEncrypted = 
			(fileHeader->algorithm == kCopyDataEncryptionAlgorithm);
	}
	else
	{
		isNotEncrypted = FALSE;
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return isNotEncrypted;
}

// GetDriveLetterPref returns the preferred drive letter setting that is
// stored in the PGPdisk's header.

PGPUInt8 
GetDriveLetterPref(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			readHeader	= FALSE;
	PGPUInt8			drive;
	PGPdiskFileHeader	*fileHeader;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	// Retrieve the drive letter field.
	if (derr.IsntError())
	{
		drive = fileHeader->drive;
	}
	else
	{
		drive = kInvalidDrive;
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return drive;
}

// SetDriveLetterPref alters the PGPdisk's header so it remembers the given
// drive letter as its preferred drive letter from now on.

DualErr 
SetDriveLetterPref(LPCSTR path, PGPUInt8 drive)
{
	DualErr				derr;
	PGPBoolean			readHeader	= FALSE;
	PGPdiskFileHeader	*fileHeader;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	// Alter the drive letter field and write out the header.
	if (derr.IsntError())
	{
		fileHeader->drive = drive;

		derr = WritePGPdiskFileMainHeader(path, fileHeader);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return derr;
}

// GetPGPdiskMountedFlag returns the value of the 'mountedFlag' header
// variable.

PGPBoolean 
GetPGPdiskMountedFlag(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			isMounted, readHeader;
	PGPdiskFileHeader	*fileHeader;

	isMounted = readHeader = FALSE;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	if (derr.IsError())
	{
		isMounted = FALSE;
	}
	else
	{
		isMounted = fileHeader->mountedFlag;
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return isMounted;
}

// SetPGPdiskMountedFlag(File *diskFile... ) sets the value of the
// 'mountedFlag' header variable on the opened PGPdisk.

DualErr 
SetPGPdiskMountedFlag(File *diskFile, PGPBoolean mountedFlag)
{
	DualErr				derr;
	PGPBoolean			readHeader	= FALSE;
	PGPdiskFileHeader	*fileHeader;

	pgpAssertAddrValid(diskFile, File);
	pgpAssert(diskFile->Opened());

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(diskFile, &fileHeader);
	readHeader = derr.IsntError();

	// Set the value of the 'mountedFlag' variable.
	if (derr.IsntError())
	{
		fileHeader->mountedFlag = mountedFlag;
		derr = WritePGPdiskFileMainHeader(diskFile, fileHeader);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return derr;
}

// SetPGPdiskMountedFlag(LPCSTR path... ) is a wrapper function.

DualErr 
SetPGPdiskMountedFlag(LPCSTR path, PGPBoolean mountedFlag)
{
	DualErr	derr;
	File	diskFile;

	pgpAssertStrValid(path);

	derr = diskFile.Open(path, kOF_MustExist);

	if (derr.IsntError())
	{
		derr = SetPGPdiskMountedFlag(&diskFile, mountedFlag);
	}

	if (diskFile.Opened())
		diskFile.Close();

	return derr;
}

// GetPGPdiskUniqueSessionId returns the value of the 'uniqueSessionId' header
// variable.

PGPUInt64 
GetPGPdiskUniqueSessionId(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			readHeader	= FALSE;
	PGPdiskFileHeader	*fileHeader;
	PGPUInt64			sessionId;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	if (derr.IsError())
	{
		sessionId = kInvalidSessionId;
	}
	else
	{
		sessionId = fileHeader->uniqueSessionId;
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return sessionId;
}

// MakePGPdiskUniqueSessionId sets the value of the 'uniqueSessionId' header
// variable.

DualErr 
SetPGPdiskUniqueSessionId(LPCSTR path, PGPUInt64 uniqueSessionId)
{
	DualErr				derr;
	PGPBoolean			readHeader	= FALSE;
	PGPdiskFileHeader	*fileHeader;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	// Set the value of the 'uniqueSessionId'.
	if (derr.IsntError())
	{
		fileHeader->uniqueSessionId = uniqueSessionId;
		derr = WritePGPdiskFileMainHeader(path, fileHeader);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return derr;
}

// DoesPGPdiskHaveBadCAST returns TRUE if the specified PGPdisk needs to be
// converted to a newer version of CAST.

PGPBoolean 
DoesPGPdiskHaveBadCAST(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			hasBadCAST, readHeader;
	PGPdiskFileHeader	*fileHeader;

	hasBadCAST = readHeader = FALSE;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	if (derr.IsError())
	{
		hasBadCAST = FALSE;
	}
	else
	{
		hasBadCAST = (fileHeader->majorVersion <= 
			kPGPdiskConvertInProgressMajorVersion);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return hasBadCAST;
}

// WasPGPdiskConversionInterrupted returns TRUE if the specified PGPdisk
// is only partially converted to the newer version of CAST.

PGPBoolean 
WasPGPdiskConversionInterrupted(LPCSTR path)
{
	DualErr				derr;
	PGPBoolean			wasInterrupted, readHeader;
	PGPdiskFileHeader	*fileHeader;

	wasInterrupted = readHeader = FALSE;

	pgpAssertStrValid(path);

	// Read the header.
	derr = ReadPGPdiskFileMainHeader(path, &fileHeader);
	readHeader = derr.IsntError();

	if (derr.IsError())
	{
		wasInterrupted = FALSE;
	}
	else
	{
		wasInterrupted = (fileHeader->majorVersion == 
			kPGPdiskConvertInProgressMajorVersion);
	}

	if (readHeader)
		FreePGPdiskFileHeader((PGPdiskFileHeaderInfo *) fileHeader);

	return wasInterrupted;
}

#if !defined(PGPDISK_NOSDK)

// NukeAllNonADKHeaders deletes all non-ADK headers on the PGPdisk. If there
// are any ADK headers, it re-encrypts them.

DualErr 
NukeAllNonADKHeaders(File *diskFile, const CASTKey *newSessionKey)
{
	DualErr					derr;
	PGPBoolean				gotItemList, gotNewItemList;
	PGPdiskFileHeaderItem	*itemList, *newList;

	gotItemList = gotNewItemList = FALSE;

	PGPBoolean				foundADKToAdd, gotAllKeys;
	PGPByte					*exportedKeyID;
	PGPdiskFileHeaderItem	*curItem;
	PGPKeyID				keyID;
	PGPKeyRef				pubKey;
	PGPKeySetRef			allKeys;

	foundADKToAdd = gotAllKeys = FALSE;

	pgpAssertAddrValid(diskFile, File);
	pgpAssert(diskFile->Opened());
	pgpAssertAddrValid(newSessionKey, CASTKey);

	// Get list of headers.
	derr = GetHeaderItemList(diskFile, &itemList);
	gotItemList = derr.IsntError();

	// Deal with ADKs.
	if (derr.IsntError())
	{
		curItem = itemList->next;

		// Open default key rings.
		derr = PGPOpenDefaultKeyRings(GetGlobalPGPContext(), 0, &allKeys);
			gotAllKeys = derr.IsntError();
		
		while (derr.IsntError() && IsntNull(curItem))
		{
			if (IsPublicKeyHeader(curItem->hdr))
			{
				PGPdiskPublicKeyHeader *pubKeyHdr;

				pubKeyHdr = (PGPdiskPublicKeyHeader *) curItem->hdr;

				// A locked key means ADK.
				if (pubKeyHdr->locked)
				{
					// Import key ID.
					exportedKeyID = (PGPByte *) pubKeyHdr + 
						pubKeyHdr->keyIDOffset;

					derr = PGPImportKeyID(exportedKeyID, &keyID);

					// Get actual key.
					if (derr.IsntError())
					{
						derr = PGPGetKeyByKeyID(allKeys, &keyID, 
							pubKeyHdr->algorithm, &pubKey);
					}

					if (derr.IsntError())
					{
						foundADKToAdd = TRUE;
					}

					break;
				}
			}

			curItem = curItem->next;
		}
	}

	// Construct new list.
	if (derr.IsntError())
	{
		derr = MakeHeaderItem(&newList);
		gotNewItemList = derr.IsntError();

		if (derr.IsntError())
		{
			derr = CopyHeader(itemList->hdr, &newList->hdr);
		}

		if (derr.IsntError())
		{
			newList->prev = newList->next = NULL;
		}
	}

	// Attach ADK.
	if (derr.IsntError() && foundADKToAdd)
	{
		PGPdiskPublicKeyHeader *newADKHeader;

		derr = CreatePublicKeyHeader(pubKey, newSessionKey, TRUE, TRUE, 
			&newADKHeader);

		if (derr.IsntError())
		{
			derr = InsertPGPdiskHeaderInList(newList, 
				(PGPdiskFileHeaderInfo *) newADKHeader);
		}
	}

	if (derr.IsntError())
	{
		UpdateHeaderItemList(diskFile, newList);
	}

	if (gotAllKeys)
		PGPFreeKeySet(allKeys);

	if (gotNewItemList)
		FreeHeaderItemList(newList);

	if (gotItemList)
		FreeHeaderItemList(itemList);

	return derr;
}

#endif	// !PGPDISK_NOSDK