Source code
Revision control
Copy as Markdown
Other Tools
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
#ifndef HashStore_h__
#define HashStore_h__
#include "Entries.h"
#include "ChunkSet.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsIFile.h"
#include "nsISupports.h"
#include "nsCOMPtr.h"
#include <string>
namespace mozilla {
namespace safebrowsing {
// The abstract class of TableUpdateV2 and TableUpdateV4. This
// is convenient for passing the TableUpdate* around associated
// with v2 and v4 instance.
class TableUpdate {
public:
TableUpdate(const nsACString& aTable) : mTable(aTable) {}
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(TableUpdate);
// To be overriden.
virtual bool Empty() const = 0;
// Common interfaces.
const nsCString& TableName() const { return mTable; }
template <typename T>
static T* Cast(TableUpdate* aThat) {
return (T::TAG == aThat->Tag() ? reinterpret_cast<T*>(aThat) : nullptr);
}
template <typename T>
static const T* Cast(const TableUpdate* aThat) {
return (T::TAG == aThat->Tag() ? reinterpret_cast<const T*>(aThat)
: nullptr);
}
protected:
virtual ~TableUpdate() = default;
private:
virtual int Tag() const = 0;
const nsCString mTable;
};
typedef nsTArray<RefPtr<TableUpdate>> TableUpdateArray;
typedef nsTArray<RefPtr<const TableUpdate>> ConstTableUpdateArray;
// A table update is built from a single update chunk from the server. As the
// protocol parser processes each chunk, it constructs a table update with the
// new hashes.
class TableUpdateV2 : public TableUpdate {
public:
explicit TableUpdateV2(const nsACString& aTable) : TableUpdate(aTable) {}
bool Empty() const override {
return mAddChunks.Length() == 0 && mSubChunks.Length() == 0 &&
mAddExpirations.Length() == 0 && mSubExpirations.Length() == 0 &&
mAddPrefixes.Length() == 0 && mSubPrefixes.Length() == 0 &&
mAddCompletes.Length() == 0 && mSubCompletes.Length() == 0 &&
mMissPrefixes.Length() == 0;
}
// Throughout, uint32_t aChunk refers only to the chunk number. Chunk data is
// stored in the Prefix structures.
[[nodiscard]] nsresult NewAddChunk(uint32_t aChunk) {
return mAddChunks.Set(aChunk);
};
[[nodiscard]] nsresult NewSubChunk(uint32_t aChunk) {
return mSubChunks.Set(aChunk);
};
[[nodiscard]] nsresult NewAddExpiration(uint32_t aChunk) {
return mAddExpirations.Set(aChunk);
};
[[nodiscard]] nsresult NewSubExpiration(uint32_t aChunk) {
return mSubExpirations.Set(aChunk);
};
[[nodiscard]] nsresult NewAddPrefix(uint32_t aAddChunk,
const Prefix& aPrefix);
[[nodiscard]] nsresult NewSubPrefix(uint32_t aAddChunk, const Prefix& aPrefix,
uint32_t aSubChunk);
[[nodiscard]] nsresult NewAddComplete(uint32_t aChunk,
const Completion& aCompletion);
[[nodiscard]] nsresult NewSubComplete(uint32_t aAddChunk,
const Completion& aCompletion,
uint32_t aSubChunk);
[[nodiscard]] nsresult NewMissPrefix(const Prefix& aPrefix);
const ChunkSet& AddChunks() const { return mAddChunks; }
const ChunkSet& SubChunks() const { return mSubChunks; }
// Expirations for chunks.
const ChunkSet& AddExpirations() const { return mAddExpirations; }
const ChunkSet& SubExpirations() const { return mSubExpirations; }
// Hashes associated with this chunk.
AddPrefixArray& AddPrefixes() { return mAddPrefixes; }
SubPrefixArray& SubPrefixes() { return mSubPrefixes; }
const AddCompleteArray& AddCompletes() const { return mAddCompletes; }
AddCompleteArray& AddCompletes() { return mAddCompletes; }
SubCompleteArray& SubCompletes() { return mSubCompletes; }
// Entries that cannot be completed.
const MissPrefixArray& MissPrefixes() const { return mMissPrefixes; }
// For downcasting.
static const int TAG = 2;
private:
// The list of chunk numbers that we have for each of the type of chunks.
ChunkSet mAddChunks;
ChunkSet mSubChunks;
ChunkSet mAddExpirations;
ChunkSet mSubExpirations;
// 4-byte sha256 prefixes.
AddPrefixArray mAddPrefixes;
SubPrefixArray mSubPrefixes;
// This is only used by gethash so don't add this to Header.
MissPrefixArray mMissPrefixes;
// 32-byte hashes.
AddCompleteArray mAddCompletes;
SubCompleteArray mSubCompletes;
virtual int Tag() const override { return TAG; }
};
// Structure for DBService/HashStore/Classifiers to update.
// It would contain the prefixes (both fixed and variable length)
class TableUpdateV4 : public TableUpdate {
public:
typedef nsTArray<int32_t> RemovalIndiceArray;
public:
explicit TableUpdateV4(const nsACString& aTable)
: TableUpdate(aTable), mFullUpdate(false) {}
bool Empty() const override {
return mPrefixesMap.IsEmpty() && mRemovalIndiceArray.IsEmpty() &&
mFullHashResponseMap.IsEmpty();
}
bool IsFullUpdate() const { return mFullUpdate; }
const PrefixStringMap& Prefixes() const { return mPrefixesMap; }
const RemovalIndiceArray& RemovalIndices() const {
return mRemovalIndiceArray;
}
const nsACString& ClientState() const { return mClientState; }
const nsACString& SHA256() const { return mSHA256; }
const FullHashResponseMap& FullHashResponse() const {
return mFullHashResponseMap;
}
// For downcasting.
static const int TAG = 4;
void SetFullUpdate(bool aIsFullUpdate) { mFullUpdate = aIsFullUpdate; }
void NewPrefixes(int32_t aSize, const nsACString& aPrefixes);
void SetNewClientState(const nsACString& aState) { mClientState = aState; }
void SetSHA256(const std::string& aSHA256);
nsresult NewRemovalIndices(const uint32_t* aIndices, size_t aNumOfIndices);
nsresult NewFullHashResponse(const Prefix& aPrefix,
const CachedFullHashResponse& aResponse);
// Clear Prefixes & Removal indice.
void Clear();
private:
virtual int Tag() const override { return TAG; }
bool mFullUpdate;
PrefixStringMap mPrefixesMap;
RemovalIndiceArray mRemovalIndiceArray;
nsCString mClientState;
nsCString mSHA256;
// This is used to store response from fullHashes.find.
FullHashResponseMap mFullHashResponseMap;
};
// There is one hash store per table.
class HashStore {
public:
HashStore(const nsACString& aTableName, const nsACString& aProvider,
nsIFile* aRootStoreFile);
~HashStore();
const nsCString& TableName() const { return mTableName; }
// Version is set to 0 by default, it is only used when we want to open
// a specific version of HashStore. Note that the intention of aVersion
// is only to pass SanityCheck, reading data from older version should
// be handled additionally.
nsresult Open(uint32_t aVersion = 0);
// Add Prefixes/Completes are stored partly in the PrefixSet (contains the
// Prefix data organized for fast lookup/low RAM usage) and partly in the
// HashStore (Add Chunk numbers - only used for updates, slow retrieval).
// AugmentAdds function joins the separate datasets into one complete
// prefixes+chunknumbers dataset.
nsresult AugmentAdds(const nsTArray<uint32_t>& aPrefixes,
const nsTArray<nsCString>& aCompletes);
ChunkSet& AddChunks();
ChunkSet& SubChunks();
AddPrefixArray& AddPrefixes() { return mAddPrefixes; }
SubPrefixArray& SubPrefixes() { return mSubPrefixes; }
AddCompleteArray& AddCompletes() { return mAddCompletes; }
SubCompleteArray& SubCompletes() { return mSubCompletes; }
// =======
// Updates
// =======
// Begin the update process. Reads the store into memory.
nsresult BeginUpdate();
// Imports the data from a TableUpdate.
nsresult ApplyUpdate(RefPtr<TableUpdateV2> aUpdate);
// Process expired chunks
nsresult Expire();
// Rebuild the store, Incorporating all the applied updates.
nsresult Rebuild();
// Write the current state of the store to disk.
// If you call between ApplyUpdate() and Rebuild(), you'll
// have a mess on your hands.
nsresult WriteFile();
nsresult ReadCompletionsLegacyV3(AddCompleteArray& aCompletes);
nsresult Reset();
private:
nsresult ReadHeader();
nsresult SanityCheck(uint32_t aVersion = 0) const;
nsresult CalculateChecksum(nsAutoCString& aChecksum, uint32_t aFileSize,
bool aChecksumPresent);
nsresult CheckChecksum(uint32_t aFileSize);
void UpdateHeader();
nsresult ReadCompletions();
nsresult ReadChunkNumbers();
nsresult ReadHashes();
nsresult ReadAddPrefixes();
nsresult ReadSubPrefixes();
nsresult ReadAddCompletes();
nsresult WriteAddPrefixChunks(nsIOutputStream* aOut);
nsresult WriteSubPrefixes(nsIOutputStream* aOut);
nsresult WriteAddCompleteChunks(nsIOutputStream* aOut);
nsresult ProcessSubs();
nsresult PrepareForUpdate();
// This is used for checking that the database is correct and for figuring out
// the number of chunks, etc. to read from disk on restart.
struct Header {
uint32_t magic;
uint32_t version;
uint32_t numAddChunks;
uint32_t numSubChunks;
uint32_t numAddPrefixes;
uint32_t numSubPrefixes;
uint32_t numAddCompletes;
uint32_t numSubCompletes;
};
Header mHeader;
// The name of the table (must end in -shavar or -digest256, or evidently
// -simple for unittesting.
const nsCString mTableName;
nsCOMPtr<nsIFile> mStoreDirectory;
bool mInUpdate;
nsCOMPtr<nsIInputStream> mInputStream;
// Chunk numbers, stored as uint32_t arrays.
ChunkSet mAddChunks;
ChunkSet mSubChunks;
ChunkSet mAddExpirations;
ChunkSet mSubExpirations;
// Chunk data for shavar tables. See Entries.h for format.
AddPrefixArray mAddPrefixes;
SubPrefixArray mSubPrefixes;
// updates from the completion server and updates from the regular server.
AddCompleteArray mAddCompletes;
SubCompleteArray mSubCompletes;
uint32_t mFileSize;
// For gtest to inspect private members.
friend class PerProviderDirectoryTestUtils;
};
} // namespace safebrowsing
} // namespace mozilla
#endif