Auditable Register Emulations

TL;DR

This paper studies auditable storage emulations, establishing bounds on their feasibility in faulty environments and proposing methods to achieve auditability through cryptographic and ordering techniques.

Contribution

It formalizes auditable register properties, proves tight bounds and impossibility results, and identifies conditions under which auditability can be achieved.

Findings

Auditability impossible if τ ≤ 2f

Weak auditability requires τ ≥ 3f+1

Signing read requests overcomes lower bounds

Abstract

The widespread prevalence of data breaches amplifies the importance of auditing storage systems. In this work, we initiate the study of auditable storage emulations, which provide the capability for an auditor to report the previously executed reads in a register. We precisely define the notion of auditable register and its properties, and establish tight bounds and impossibility results for auditable storage emulations in the presence of faulty storage objects. Our formulation considers loggable read-write registers that securely store data using information dispersal and support fast reads. In such a scenario, given a maximum number~$f$ of faulty storage objects and a minimum number~$\tau$ of data blocks required to recover a stored value, we prove that (1) auditability is impossible if $\tau \leq 2f $; (2) implementing a weak form of auditability requires $\tau \geq 3f+1$; and (3) a stronger form of auditability is impossible. We also show that signing read requests overcomes the lower bound of weak auditability, while totally ordering operations or using non-fast reads enables strong auditability.

Figures

Tables

Table 1. Table 1 : Required number  t 𝑡 t of collected records for creating read evidences and number  τ 𝜏 \tau of blocks to read a value in each considered model for each audit property or combination of properties.

		Weak	Completeness +	Strong	Completeness +
Model	Completeness	Accuracy	Weak Accuracy	Accuracy	+ Strong Accuracy
Our System Model	$𝝉\ge \mathrm{𝟐}𝒇+\mathrm{𝟏}$	$t\ge f+1$	$\tau \ge 3f+1$	$t\ge \tau +f$	Impossible
Signed Reads (SR)		$𝒕\ge \mathrm{𝟏}$	$𝝉\ge \mathrm{𝟐}𝒇+\mathrm{𝟏}$
Total Order (TO)		$t\ge f+1$	$\tau \ge 3f+1$	$t\ge f+1$	$\tau \ge 3f+1$
Non-Fast Reads (NF)
TO+SR		$𝒕\ge \mathrm{𝟏}$	$𝝉\ge \mathrm{𝟐}𝒇+\mathrm{𝟏}$
NF+SR				$𝒕\ge \mathrm{𝟏}$	$𝝉\ge \mathrm{𝟐}𝒇+\mathrm{𝟏}$

Full text

1 Introduction

Characteristics like cost-effectiveness, high scalability, and ease of use promoted the migration from private storage infrastructures to public multi-tenant clouds in the last decade. Security and privacy concerns were the main deterrents for this migration since the beginning. Numerous secure storage systems have been proposing the use of advanced cryptographic primitives to securely disperse data across multiple clouds (i.e., independent administrative domains [2]) to reduce the risk of data breaches (e.g., DepSky [7] and AONT-RS [28]).

Given a secure storage system composed of $n$ storage objects, these information dispersal techniques split and convert the original data item into $n$ coded blocks [21, 25, 27]. Each coded block is stored in a different base object and clients need to obtain only $\tau$ out of $n$ coded blocks to effectively recover the original data. In this type of solution, no base object stores the whole data item, which differentiates information dispersal from fully-replicated storage systems (e.g., [1, 5, 24])—where each object retains a full copy of the data.

Despite the advances in secure storage, the increasing severity of data breaches and the tightening of privacy-related regulations (e.g., GDPR) have been driving the demand for further improvements on this topic. For instance, auditability [19] enables the systematic verification of who has effectively read data in secure storage systems. Notably, this verification allows one to separate these users from the whole set of clients that are authorised to read data but have never done so. It is an important step to detect data breaches (including those caused by authorised users, e.g., Snowden’s case), analyse leakages, and sanction misuses.

Problem.

In this paper, we address the following question: How to extend resilient storage emulations with the capability of auditing who has effectively read data? More specifically, we address the problem of protecting storage systems from readers trying to obtain data without being detected (i.e., audit completeness) and protecting correct readers from faulty storage objects trying to incriminate them (i.e., audit accuracy). The answer must encompass the techniques used in these emulations, such as information dispersal [21, 27] and available quorum systems [24], for providing a R/W register abstraction [22]. We consider information dispersal the primary form of auditable register emulations because alternative solutions that replicate the whole data (even if encrypted) can suffer from faulty base objects leaking data (and encryption keys) to readers without logging this operation.

Related Work.

Several auditing schemes were proposed to verify the integrity of data stored in multi-tenant external infrastructures [20, 26]. They mainly focus on cryptographic techniques to produce retrievability proofs without the need to fetch all data from the system (e.g., [18]) or on providing public integrity verification (e.g., [31]). However, to the best of our knowledge, there is no previous work on auditing who has effectively read data in a dispersed storage.

Another topic related to our work is the accountability, which focuses on making systems’ components accountable in a way their actions become non-repudiable [13]. Works in the accountability literature have discussed generic scenarios for networked systems [14], described the necessary cryptographic building blocks [13], or how evidences should be stored and protected [14].

Several other works have explored the space complexity of fault-tolerant register emulations (e.g., [3, 8, 9, 10]), including disintegrated storage [6] (e.g., [4, 7, 30]). However, none of these works focuses on the requirements for auditing read accesses in a storage system despite the existence of faulty storage objects.

Contributions.

This paper initiates the study of auditing in resilient storage by presenting lower bounds and impossibility results related with the implementation of an auditable register on top of $n$ base objects that log read attempts despite the existence of $f$ faulty ones. Our results show that, given a minimum number $\tau$ of data blocks required to recover a data item from information dispersal schemes and a maximum number $f$ of faulty storage objects (1) auditability is impossible with $\tau\leq 2f$; (2) when fast reads (reads executed in a single communication round-trip [11]) are supported, $\tau\geq 3f+1$ is required for implementing a weak form of auditability, while a stronger form of auditability is impossible; (3) signing read requests overcomes the lower bound of weak auditability; and (4) totally ordering operations or using non-fast reads can still provide strong auditability.

2 Preliminaries

System Model.

Our system is composed of an arbitrary number of client processes $\Pi=\{p_{1},p_{2},...\}$, which interact with a set of $n$ storage objects $\mathds{O}=\{o_{1},o_{2},...,o_{n}\}$. Clients can be subdivided into three main classes: writers $\Pi_{W}=\{p_{w1},p_{w2},...\}$, readers $\Pi_{R}=\{p_{r1},p_{r2},...\}$, and auditors $\Pi_{A}=\{p_{a1},p_{a2},...\}$. These different roles do not necessarily mean they have to be performed by different processes.

A configuration $C$ is a vector of the states of all entities (i.e., processes and objects) in the system. An initial configuration is a specific configuration where all entities of the system are in their initial state. An algorithm $\mathit{Alg}$ defines the behaviour of processes in $\Pi$ and objects in $\mathds{O}$ as deterministic state machines, which can modify the system’s states through actions (e.g., invoke and response). Clients invoke operations in the storage objects and wait for responses. An execution segment is a (finite or infinite) sequence of alternated configurations and actions. An execution $\rho$ is an execution segment that begins in an initial configuration. An event is the occurrence of an action in an execution.

A finite sequence of invocations and responses compose a history $\sigma$ of the system. We consider the following relationships between operations within a history. First, if a history $\sigma$ contains the invocation of an operation $op_{1}$ and its response, then $op_{1}$ is complete in $\sigma$. Otherwise, if $\sigma$ contains only the former, then operation $op_{1}$ is incomplete. Second, if the response of an operation $op_{1}$ precedes the invocation of another operation $op_{2}$ in $\sigma$, then $op_{1}$ precedes $op_{2}$. Third, if operations $op_{1}$ and $op_{2}$ do not precede each other in $\sigma$, then they are concurrent. Fourth, a history $\sigma$ that does not contain concurrent operations is sequential.

Information Dispersal.

We consider a high-level shared storage object that stores a value $v$ from domain $\mathds{V}$ using information dispersal schemes (i.e., a special case of disintegrated storage [6]). These schemes provide efficient redundancy since they disperse pieces of information across multiple locations instead of replicating the whole value on each one of them. Moreover, they allow clients to recover the original stored value only after obtaining a subset of these pieces of information. Examples of information dispersal schemes include erasure codes [25, 27] and secret sharing [21, 29].

This object provides two high-level operations: a-write($v$) and a-read(). A high-level a-write($v$) operation converts a value $v\in\mathds{V}$, passed as an argument, into $n$ coded blocks $b_{v_{1}},b_{v_{2}},...,b_{v_{n}}$ from domain $\mathds{B}$, and each coded block $b_{v_{k}}$ is stored in the $k^{th}$ base object in $\mathds{O}$ (as described bellow). The employed techniques guarantee that no untrusted base object $o_{k}$ stores an entire copy of value $v$ and no reader recovers $v$ by obtaining less than a certain fraction of these blocks.

A high-level a-read() operation recovers the original value $v$ from any subset of a specific number ($\tau$) of blocks $b_{v_{k}}$. It means readers do not need to execute low-level reads in all $n$ base objects to obtain these $\tau$ blocks. Base objects in this work are loggable R/W registers.

Loggable R/W Register Specification.

A loggable read-write (R/W) register is an object $o_{k}$ that stores a data block $b_{v_{k}}$ from domain $\mathds{B}$ and has a log $L_{k}$ to store records of every read operation that this base object has responded. This object $o_{k}$ provides three low-level operations [22]:

• •

rw-write($b_{v_{k}}$): writes the data block $b_{v_{k}}\in\mathds{B}$, passed as an argument, in this base object $o_{k}$ and returns an ack to confirm that the operation has succeeded.

• •

rw-read(): returns the data block $b_{v_{k}}\in\mathds{B}$ currently stored in this base object $o_{k}$ (or $\perp\notin\mathds{B}$ if no block has been written on it).

• •

rw-getLog(): returns the log $L_{k}$ of this base object $o_{k}$.

The behaviour of a loggable R/W register is given by its sequential specification. A low-level rw-write operation always writes the block passed as an argument and returns an ack. A low-level rw-read operation returns the block written by the last preceding rw-write operation on this object or $\perp\notin\mathds{B}$ if no write operation has been executed in this object. Additionally, the low-level rw-read operation also creates a record $\langle p_{r},\mathit{label}(b_{v_{k}})\rangle$ about this read operation in its log $L_{k}$, where $p_{r}$ is the identifier of the reader that invoked the rw-read operation and label($b_{v_{k}}$) is an auxiliary function that, given a block $b_{v_{k}}$, returns a label associated with the value $v$ (from which the block $b_{v_{k}}$ was derived). A low-level rw-getLog returns the log $L_{k}$ containing records of all preceding rw-read executed in this object $o_{k}$. A history $\sigma$ of low-level operations in this object is linearisable [16] if invocations and responses of concurrent operations can be reordered to form a sequential history that is correct according to its sequential specification. This object is linearisable if all of its possible histories are also linearisable.

We define a providing set based on the notion introduced by Lamport [23] to abstract the access to multiple base objects. A providing set is the set of base objects that have both stored a block associated with value $v$ and responded this block to a reader $p_{r}$ in history $\sigma$.

Definition** 1**** (Providing Set).**

The set of objects $P^{\sigma}_{p_{r},v}$ is providing blocks associated to value $v$ for the reader $p_{r}$ in a history $\sigma$ iff $\sigma$ contains, for every object $o_{k}\in P^{\sigma}_{p_{r},v}$, an event in which $o_{k}$ receives a write request to store $b_{v_{k}}$ and an event in which $o_{k}$ responds $b_{v_{k}}$ to a read request from $p_{r}$.

Given a finite history $\sigma$ being audited, there is only one possible providing set $P^{\sigma}_{p_{r},v}$ for each pair $\langle p_{r},v\rangle$ of reader $p_{r}$ and value $v$. For the sake of simplicity, this set is presented only as $P_{p_{r},v}$ from now on. Every single base object $o_{k}$ that stored block $b_{v_{k}}$ and returned this block to $p_{r}$ belongs to the providing set $P_{p_{r},v}$, independent on how many times $o_{k}$ has returned $b_{v_{k}}$ to $p_{r}$. There might exist cases where providing sets for different pairs of readers and values are composed of the same objects.

We introduce the notion of an effective read, which characterises a providing set large enough that a reader $p_{r}$ is able to effectively read value $v$ from the received blocks.

Definition** 2**** (Effective read).**

A value $v\in\mathds{V}$ is effectively read by a reader $p_{r}$ in history $\sigma$ iff $|P^{\sigma}_{p_{r},v}|\geq\tau$, i.e., $p_{r}$ has received at least $\tau$ distinct blocks $b_{v_{k}}$ associated with value $v$ from different base objects $o_{k}\in P^{\sigma}_{p_{r},v}$ in history $\sigma$.

An effective read depends only on the number of different coded blocks (derived from the same value $v$) that a reader $p_{r}$ has already obtained from different base objects in the same history. Reader $p_{r}$ does not necessarily obtain all these blocks in a single high-level a-read operation. Due to unlimited concurrency, there might exist cases where it is accomplished only after receiving responses from many subsequent a-read operations.

High-level operations in our system have two additional particularities. First, high-level read operations (i.e., a-read) are fast reads.

Definition** 3**** (Fast read [11]).**

An a-read operation is fast if it completes in a single communication round-trip between the reader and the storage objects.

Second, we consider multi-writer multi-reader (MWMR) shared objects where multiple writers from $\Pi_{w}$ execute high-level a-write operations and multiple readers from $\Pi_{R}$ execute high-level a-read operations.

Fault Model.

Clients (i.e., writers, readers, and auditors) and storage objects that obey their specifications are said to be correct. Faulty writers and faulty auditors are honest and can only fail by crashing. Faulty readers may crash or request data to only a subset of objects, which may characterise an attack where it attempts to read data without being detected and reported by the audit.

Writers are trusted entities because they are the data owners, who are the most interested party in the auditable register we are proposing in this work. This assumption is common (e.g., [7, 24]) since malicious writers can always write invalid values, compromising the application’s state. Furthermore, auditors are also trusted because they are controlled either by the same entity as writers or by third-party entities writers trust.

Faulty storage objects can be nonresponsive (NR) [17] in an execution since they may crash, omit their values to readers, omit read records to auditors, or record nonexistent read operations. More specifically, they can fail by NR-omission when accessing their values and NR-arbitrary when accessing their log records [17]. Omitting records to auditors means a faulty object may be helping a reader to evict being detected by the auditor. Producing records for nonexistent reads characterises an attack where a faulty object may be trying to incriminate a reader. Furthermore, we assume no more than $f$ storage objects are faulty.

3 Auditable Register Emulations

We extend the aforementioned register emulation with a high-level operation a-audit(). It uses the fail-prone logs obtained from the rw-getLog operation in loggable R/W registers to define an auditable register emulation. This emulation has access to a virtual log $L\subseteq\bigcup_{k\in\{1..n\}}L_{k}$ from which we can infer who has effectively read a value from the register.

The a-audit operation obtains records from $L$ and produces a set of evidences $E_{A}$ about the effectively read values. We define a threshold $t$ as the required number of collected records to create an evidence $\mathcal{E}_{p_{r},v}$ of an effective read. Each evidence $\mathcal{E}_{p_{r},v}$ contains at least $t$ records from different storage objects $o_{k}$ proving that $v$ was effectively read by reader $p_{r}$ in history $\sigma$. This threshold $t$ is a configurable parameter that depends on the guarantees a-audit operations provide (defined bellow).

We define an auditing quorum $A$ as the set of objects from which the a-audit collects fail-prone individual logs to compose the set of evidences. To ensure audit operations are available in our asynchronous system model, we consider $|A|=n-f$. We are interested in auditing effective reads because we aim to audit who has actually read a data value $v$—including faulty readers that do not follow the read protocol and leave operations incomplete. A correct auditor receives $E_{A}$ and reports all evidenced reads.

An auditable register provides an a-audit() operation that guarantees completeness (i.e., Definition 4) and at least one form of accuracy (i.e., Definitions 5 and 6).

Definition** 4**** (Completeness).**

Every value $v$ effectively read by a reader $p_{r}$ before the invocation of an a-audit in history $\sigma$ is reported in the $E_{A}$ from this audit operation, i.e., $\forall p_{r}\in\Pi_{R},\forall v\in\mathds{V},|P_{p_{r},v}|\geq\tau\implies\mathcal{E}_{p_{r},v}\in E_{A}$.

Definition** 5**** (Weak Accuracy).**

A correct reader $p_{r}$ that has never invoked an a-read (i.e., never tried to read any value $v$) before the invocation of an a-audit in history $\sigma$ will not be reported in the $E_{A}$ from this audit operation, i.e., $\forall p_{r}\in\Pi_{R},\forall v\in\mathds{V},P_{p_{r},v}=\varnothing\implies\mathcal{E}_{p_{r},v}\notin E_{A}$.

Definition** 6**** (Strong Accuracy).**

A correct reader $p_{r}$ that has never effectively read a value $v$ before the invocation of an a-audit in history $\sigma$ will not be reported in the $E_{A}$ from this audit operation as having read $v$, i.e., $\forall p_{r}\in\Pi_{R},\forall v\in\mathds{V},|P_{p_{r},v}|<\tau\implies\mathcal{E}_{p_{r},v}\notin E_{A}$.

While completeness is intended to protect the storage system from readers trying to obtain data without being detected, accuracy focuses on protecting correct readers from faulty storage objects incriminating them.

Both variants of accuracy guarantee that auditors report only readers that have invoked read operations. The difference between them is that strong accuracy guarantees that auditors report only readers that have effectively read some value, while weak accuracy may report readers that have not effectively read any value. Strong accuracy implies weak accuracy. Additionally, the accuracy property provides guarantees to correct readers only, which means that auditors may report faulty (honest or malicious) readers in incomplete or partial reads because they had the intention to read the data and aborted it or crashed while doing so.

We consider weak auditability when the storage system provides completeness and weak accuracy in audit operations and strong auditability when it provides completeness and strong accuracy.

4 Preliminary Results

In the presence of faulty base objects, it is impossible to audit system in which readers can recover values by accessing a single object (e.g., non-replicated and fully-replicated systems). The reason is that, in these solutions, every base object stores a full copy of data and can give it to readers without returning the log record of this operation to auditors. Therefore, we consider information dispersal techniques (e.g., [21, 27]) as the primary form of auditable register emulations. Moreover, we assume these information dispersal schemes require $\tau>f$ blocks to recover the data because, otherwise, the $f$ faulty objects may also deliver their blocks to readers and omit the records of these operations from auditors.

Records Available for Auditing Registers.

As a starting point, we identify the minimum number of records from each preceding effective read that will be available for any a-audit operation. It relates to the minimum number of correct objects that are present at the smallest intersection of any providing set $P_{p_{r},v}$ and an auditing quorum $A$.

Lemma** 1****.**

Any available a-audit operation obtains at least $\tau-2f$ records of every preceding effective read in history $\sigma$.

Proof.

Let us assume a system configuration composed of $n$ storage objects divided into four groups $G_{1-4}$, as depicted in Figure 1. Objects within the same group initially contain the same value $v$ and an empty log $L_{k}=\varnothing$. Without loss of generality, group $G_{1}$ contains the $f$ faulty objects of the system, $G_{2}$ contains $\tau-2f$ correct objects, $G_{3}$ contains $f$ correct objects, and $G_{4}$ contains the remaining $n-\tau$ correct objects of the system.

A reader $p_{r1}$ effectively reads a value $v$ after obtaining exactly $\tau$ blocks $b_{v_{k}}$ from objects in a providing set $P_{p_{r1},v}$ composed of the $f$ faulty objects in $G_{1}$ (that do not record the read operation) and $\tau-f$ correct objects in $G_{2}\cup G_{3}$ (that do record it). In the worst-case scenario, an available a-audit operation receives $n-f$ rw-getLog responses from an auditing quorum $A$ composed of the $f$ faulty objects in $G_{1}$ (that belong to the providing set $P_{p_{r1},v}$ but return empty logs $L_{k}$ to auditors), $\tau-2f$ correct objects in $G_{2}$ (that belong to the providing set $P_{p_{r1},v}$ and return the correct records of this read operation), and $n-\tau$ correct objects in $G_{4}$ (that do not belong to $P_{p_{r1},v}$).

In this case, auditors receive only the $\tau-2f$ records from the objects in $G_{2}$, which are the only correct objects at the intersection of $P_{p_{r1},v}$ and $A$. This is the minimum number of records of an effective read available to an auditing quorum since any other configuration makes auditors receive more records of this effective read, i.e., in any alternative scenario, the faulty objects in $G_{1}$ may correctly record the read operation and return these records to auditors or the auditing quorum $A$ may also include up to $f$ correct objects from $G_{3}$ (that belong to $P_{p_{r1},v}$) instead of objects from $G_{4}$. ∎

Receiving this minimum number $\tau-2f$ of records from an effective read must be enough to trigger the creation of an evidence for that read in a-audit operations. As a consequence, the value of $t$ must be defined considering this constraint.

5 Impossibility Results

This section identifies impossibility results for the properties of auditable registers: completeness (Definition 4), weak accuracy (Definition 5), and strong accuracy (Definition 6).

Lemma** 2****.**

It is impossible to satisfy the completeness of auditable registers with $\tau\leq 2f$.

Proof.

Consider an auditable register implemented using the same four subset groups of objects $G_{1-4}$ from Lemma 1 (depicted in Figure 1). Without loss of generality, let us assume that $\tau=2f$. As a consequence, group $G_{2}$ will be empty because $|G_{2}|=\tau-2f=0$.

A reader $p_{r1}$ obtains $\tau$ coded blocks for value $v$ from a providing set $P_{p_{r1},v}$ composed of $f$ faulty objects in $G_{1}$ (which do not log the operation) and $\tau-f=f$ correct nodes in $G_{3}$ (that log the operation). This reader can decode the original value $v$ after receiving these $\tau$ blocks, performing thus an effective read. Consequently, $|G_{2}|=0$ and any auditing quorum $A$ that does not include at least one object from $G_{3}$ will not receive any record for the read operation from reader $p_{r1}$. For instance, an auditing quorum $A=G_{1}\cup G_{2}\cup G_{4}$ (e.g., from Figure 1) receives no record of this read in this history, which violates the completeness property since an evidence cannot be created without records (i.e., $t\geq 1$). ∎

Lemma** 3****.**

It is impossible to satisfy the weak accuracy of auditable registers with $t\leq f$.

Proof.

Consider an auditable register implemented using $n-f$ correct objects and $f$ faulty objects. A read has never been invoked in this history of the system, but the $f$ faulty objects create records for a nonexistent read operation from a reader $p_{r}$. Any auditing quorum $A$ that includes these faulty objects will receive $f$ records for a read operation that has never been invoked. If the threshold $t\leq f$ is enough to create an evidence and report an effective read, then a correct auditor must report it, violating the weak accuracy property. ∎

The next theorem shows in which conditions these two properties cannot be supported simultaneously.

Theorem** 1****.**

It is impossible to satisfy both completeness and weak accuracy of auditable registers with $\tau\leq 3f$.

Proof.

Consider an auditable register implemented using the same four subset groups of objects $G_{1-4}$ from Lemma 1 (depicted in Figure 1). Without loss of generality, let us assume that $\tau=3f$ is enough to satisfy both the completeness and weak accuracy properties. As a consequence, group $G_{2}$ will contain $|G_{2}|=\tau-2f=f$ objects.

A reader $p_{r1}$ obtains $\tau$ blocks for value $v$ from a providing set $P_{p_{r1},v}$ composed of $f$ blocks from the faulty objects in $G_{1}$ (which do not log the operation) and other $\tau-f$ correct objects in $G_{2}\cup G_{3}$ (that log the operation). The auditing quorum $A$ will produce $\tau-2f=f$ records (Lemma 1). Evidences must be created using these $f$ records to report the effective read and satisfy completeness. However, as proved in Lemma 3, it is impossible to guarantee weak accuracy with $t\leq f$. ∎

Now, we turn our attention to strong accuracy, i.e., the capability of an auditor to report exactly which value $v$ each reader $p_{r}$ has effectively read.

Lemma** 4****.**

It is impossible to satisfy the strong accuracy of auditable registers with $t<\tau+f$.

Proof.

Consider an auditable register implemented using five subset groups of objects $G_{1-5}$, as depicted in Figure 2. The main difference to the scenario from Figure 1 is that the group $G_{4}$ was subdivided into two groups: $G_{4}$ with $2f-1$ objects and $G_{5}$ with $n-\tau-2f+1$ objects.

This configuration has an incomplete write operation111An incomplete write operation may be caused, for instance, by network delays in clients’ requests or a writer that has crashed in the middle of a write operation. of a value $x\in\mathds{V}$ that has arrived to objects from all groups but $G_{2}$ and $G_{4}$. A reader $p_{r2}$ obtains blocks of value $v$ from objects from groups $G_{2}$ and $G_{4}$, which log the record for the read, and form a providing set with size $|P_{p_{r2},v}|=\tau-2f+2f-1=\tau-1$. In this history, due to the incomplete write operation of value $x$, reader $p_{r2}$ has not received $\tau$ blocks for value $v$, which means it cannot recover $v$.

However, the $f$ faulty objects in $G_{1}$ decide to mimic groups $G_{2}$ and $G_{4}$ and log the record for the read of value $v$ by reader $p_{r2}$. Any auditing quorum $A$ that includes the objects from groups $G_{1}$, $G_{2}$, and $G_{4}$ will return $\tau+f-1$ records. If $t<\tau+f$ is enough to produce an evidence of an effective read, then the auditor will report this read from reader $p_{r2}$ (i.e., not an effective read), violating the strong accuracy property. ∎

Theorem** 2****.**

It is impossible to satisfy both completeness and strong accuracy of auditable registers.

Proof.

Consider an auditable register implemented using the same five subset groups of objects $G_{1-5}$ from Lemma 4 (depicted in Figure 2). Without loss of generality, let us assume $\tau\geq 2f+1$ is required to guarantee the completeness of audit operations (Lemma 2). As a consequence, $G_{2}$ contains $\tau-2f\geq 1$ object and $G_{5}$ contains $n-\tau-2f+1\leq n-4f$ objects.

A reader $p_{r1}$ executes a read operation in groups $G_{1-3}$. Faulty objects from $G_{1}$ return their blocks for value $v$ (but do not log the read operation). Reader $p_{r1}$ receives exactly $\tau$ correct data blocks and obtains the original value $v$ (i.e., an effective read).

A writer $p_{w}$ leaves incomplete an operation to write a value $x$, similarly to the configuration of Lemma 4, which has been received by objects in all groups but $G_{2}$ and $G_{4}$. A second reader $p_{r2}$ executes a read operation that receives $\tau-1$ blocks for value $v$ from a providing set $P_{p_{r2},v}$. These $\tau-1$ blocks are insufficient to recover the original value $v$ (i.e., it does not represent an effective read). Faulty objects from $G_{1}$ decide to mimic groups $G_{2}$ and $G_{4}$ and log the read of $v$ by $p_{r2}$.

After these two reads, any auditing quorum $A$ that includes $G_{4}$ receives the same number or more records of the read from $p_{r2}$ (i.e., not an effective read) than records of the effective read from $p_{r1}$. As a consequence, it is impossible to define a single reporting threshold $t$ to be used to produce evidences without violating either completeness or strong accuracy.

For instance, the auditing quorum $A=G_{1}\cup G_{2}\cup G_{4}\cup G_{5}$ receives $\tau+f-1$ records $\langle p_{r2},\emph{label}(b_{v_{k}})\rangle_{k}$ and $\tau-2f$ records $\langle p_{r1},\emph{label}(b_{v_{k}})\rangle_{k}$. Defining $t\leq\tau-2f$ is enough to report the effective read from $p_{r1}$, but it violates the strong accuracy by also reporting the (not effective) read from $p_{r2}$. Alternatively, defining $t\geq\tau+f$ satisfies the strong accuracy because it does not report the read from $p_{r2}$, but it violates the completeness because it does not report the effective read from $p_{r1}$. ∎

Remark: Adding any number of objects to the scenario of Figure 2 does not change the impossibility result of Theorem 2. The reason is that with the unlimited concurrency in our model, each additional object may have a value different from all values stored in the other objects.

6 Audit Algorithm

We present a generic auditability algorithm for register emulations and prove that all bounds from the previous section (Lemmata 2–4 and Theorem 1) are tight in our system model when using this algorithm. Concretely, we prove that this algorithm satisfies the completeness property with $t\geq 1$ and $\tau\geq 2f+1$ (Lemma 5) and the weak accuracy with $t\geq f+1$ (Lemma 6). Then, we prove that it supports both completeness and weak accuracy with $t\geq f+1$ and $\tau\geq 3f+1$ (Theorem 3). Finally, we prove it supports the strong accuracy property alone with $t\geq\tau+f$ (Lemma 7).

The implementation for a-audit() is presented in Algorithm 1. It starts with an empty set $E_{A}$ that will be used to store the evidences attesting the effective reads and an array of empty logs to store the logs it will receive from objects (Line 2). It then queries $n$ storage objects to obtain the list of records on objects’ logs (i.e., $o_{k}$.getLog()), waits the response from at least $n-f$ of them, and stores these responses in the array of logs $L$ (Lines 3–4).

For each previously seen record (Line 5), it adds the identifier of every object containing this record to an evidence $\mathcal{E}_{p_{r},v}$ (Line 6). If this evidence contains more than $t$ identifiers, then it refers to an effective read and is added to the reporting set of evidences $E_{A}$ (Line 7). After verifying all records, the audit operation returns the set $E_{A}$ (Line 8), which is used by auditors to report that the detected readers have effectively read the mentioned data values.

Lemma** 5****.**

Algorithm 1 satisfies the completeness property of auditable registers with $t\geq 1$ and $\tau\geq 2f+1$.

Proof.

Based on Lemma 1, if $\tau\geq 2f+1$, any auditing quorum $A$ receives, for every effective read, at least one record from a correct storage object that has also participated on the providing set of this read (i.e., $\tau-2f\geq 1$). Consequently, Algorithm 1 satisfies completeness by obtaining some record from any effective read. ∎

Lemma** 6****.**

Algorithm 1 satisfies the weak accuracy of auditable registers with $t\geq f+1$.

Proof.

To support the weak accuracy of auditable registers, Algorithm 1 simply needs to make the $f$ records from faulty objects insufficient to create an evidence reporting an effective read from a reader $p_{r}$. Therefore, $t\geq f+1$ ensures that any auditing quorum $A$ includes at least one correct object that received a read request from this reader and participates in the providing set $P_{p_{r}},v$. ∎

Theorem** 3****.**

Algorithm 1 satisfies both completeness and weak accuracy of auditable registers with $\tau\geq 3f+1$.

Proof.

Assuming $\tau\geq 3f+1$ directly satisfies completeness (Lemma 5). Based on Lemma 1, any auditing quorum $A$ receives at least $\tau-2f\geq f+1$ records from correct storage objects that have participated on the providing sets of each effective read. As proved in Lemma 6, $t\geq f+1$ is enough for Algorithm 1 to satisfy also weak accuracy. ∎

A practical consequence of Theorem 3 is that existing information dispersal schemes that support fast reads using $n\geq\tau+2f$ objects, such as Hendricks et. al [15], would require at least $n~{}\geq~{}5f+1$ to support this weak auditability.

Lemma** 7****.**

Algorithm 1 satisfies the strong accuracy of auditable registers with $t\geq\tau+f$.

Proof.

To support the strong accuracy property of auditable registers, evidences must be created using at least $\tau$ records attesting the read of the same value from correct storage objects that have participated in the providing sets of each effective read. Since $f$ faulty objects can mimic these objects and also participate in an auditing quorum $A$, this number $f$ must be added to the threshold number $t$ of records required to create an evidence. These two requirements make strong accuracy satisfiable with $t\geq\tau+f$ by accessing any auditing quorum $A$ because, in this case, the records from the $f$ faulty objects make no difference when reporting a value effectively read by a reader. ∎

7 Alternative Models for the Algorithm

As proved in Theorems 1 and 2, respectively, weak auditability is impossible with $\tau\leq 3f$ and strong auditability is impossible in our system model. In the following, we present three modifications to our system model that allow Algorithm 1 to overcome these negative results. More specifically, signing read requests makes weak auditability easier (Section 7.1), while totally ordering operations (Section 7.2) or using non-fast reads (Section 7.3) enables strong auditability. Table 1 presents an overview of the results in our system model and models with these three modifications.

7.1 Signed Read Requests

Digital signatures are tamper-proof mechanisms that enable attesting the authenticity and integrity of received messages. Correct readers may sign their read requests to mitigate being incriminated by faulty objects.

In general, readers signing requests prevents a faulty object from creating correct records about them if this object has never received a signed request from them before. It does not modify the number of records from an effective read available to auditors (Lemma 1) nor does it modify the lower bound on the completeness (Lemma 5). However, it directly relates to the weak accuracy property since auditors receiving any correct record with a signed read request is enough for them to attest that a reader has definitely tried to read data in the storage system.

Lemma** 8****.**

Correct readers signing read requests in our model allows Algorithm 1 to satisfy weak accuracy with $t~{}\geq~{}1$.

Proof.

If read requests from correct readers are signed and these readers have never sent signed requests to the storage system, faulty objects will never create correct records about these readers. As a result, $t\geq 1$ ensures that auditors will only create evidences for the readers that have tried to read data by sending signed requests to the storage objects. ∎

Theorem** 4****.**

Correct readers signing read requests in our model allows Algorithm 1 to satisfy both completeness and weak accuracy with $\tau\geq 2f+1$.

Proof.

With $\tau\geq 2f+1$ and based on Lemma 1, any auditing quorum $A$ receives at least $\tau-2f=1$ record from a correct storage object that has participated on each effective read. As proved in Lemma 8, $t\geq 1$ is enough to satisfy weak accuracy in our model when read requests are signed. Moreover, this limitation does not change the lower bound of Lemma 5, which means that $\tau\geq 2f+1$ is enough for Algorithm 1 to also satisfy completeness in our model. ∎

Faulty objects can still repurpose generic signed read requests to create correct records of an arbitrary value. For that reason, signing generic read requests does not modify the lower bounds of strong accuracy (Lemma 7) and supporting it in conjunction with completeness remains impossible (Theorem 2).

Alternatively, correct readers can sign the read request with the label of the exact value they intend to read (e.g., a timestamp). However, additional modifications are required to enable readers learning this label before sending the read request, as will be explained in Section 7.3.

7.2 Total Order

Serialising operations using total order broadcast [12] allows our system to execute operations sequentially. By doing so, we limit the number of different values in storage objects to only one value since high-level a-read and a-write operations are executed in total order. In the worst case, the system will have $f$ faulty objects with incorrect read records. With this limitation, strong accuracy becomes easier and can be satisfied together with completeness.

Lemma** 9****.**

Totally ordering operations in our model allows Algorithm 1 to satisfy strong accuracy with $t\geq f+1$.

Proof.

If operations are totally ordered in the system, all objects will store blocks of the same value $v$, and no object returns blocks of other values. No read operation will result in correct records for more than one data value, and every read operation results in the creation of records in at least $n-f$ objects. The worst case is when the $f$ faulty objects log incorrect read records for a value other than $v$. As a result, any auditing quorum $A$ that includes the faulty objects will receive $f$ records attesting the read of a value other than $v$. Requiring $t\geq f+1$ to create an evidence guarantees that at least one correct object has also participated in the providing set $P_{p_{r},v}$, which guarantees that $n-f$ objects will also return their blocks, allowing $p_{r}$ to effectively read the value $v$. ∎

Theorem** 5****.**

Totally ordering operations in our model allows Algorithm 1 to satisfy both completeness and strong accuracy with $\tau\geq 3f+1$.

Proof.

With $\tau\geq 3f+1$ and based on Lemma 1, any auditing quorum $A$ receives at least $\tau-2f=f+1$ records from correct storage objects that have participated on each effective read of value $v$. As proved in Lemma 9, $t\geq f+1$ is enough to satisfy strong accuracy in our model when operations are totally ordered. Moreover, this limitation does not change the lower bound of Lemma 5, which means that $\tau\geq 3f+1$ is enough for Algorithm 1 to also satisfy completeness in our model. ∎

As proved in Lemma 8, signing generic read requests reduces the lower bound of weak accuracy, which also benefits the model with total ordering (see Table 1). However, as previously mentioned, these generic signatures do not modify the lower bounds of strong accuracy.

7.3 Non-fast Reads

There are read algorithms that use more than one communication round (i.e., a non-fast read [11]) to ensure correct readers will only fetch the blocks of the most up-to-date value stored in the register. For instance, DepSky-CA [7] is a register emulation in which the first round of a read obtains the label of the most up-to-date value available in $n-f$ objects, while the second round actually reads only the coded blocks for that specific value. As a consequence, correct objects log reads from readers only if they hold the most up-to-date value available in at least $n-f$ objects.

Lemma** 10****.**

Applying Algorithm 1 to DepSky-CA protocol satisfies strong accuracy with $t~{}\geq~{}f+1$.

Proof.

Let us assume registers follow DepSky-CA protocol [7] with two communication rounds in read operations. No read operation will result in correct records for more than one data value, and every read operation results in the creation of records in at least $n-f$ objects. In the worst-case scenario, the $f$ faulty storage objects can only create at most $f$ incorrect records for an arbitrary value. Requiring $t\geq f+1$ to create an evidence and report an effective read guarantees that it is achieved only when the reported value was effectively read from $n-f$ objects. ∎

Theorem** 6****.**

Applying Algorithm 1 to DepSky-CA protocol satisfies both completeness and strong accuracy with $\tau\geq 3f+1$.

Proof.

Let us assume registers follow DepSky-CA protocol [7] with two communication rounds in read operations. Assuming $\tau\geq 3f+1$ and based on Lemma 1, any auditing quorum $A$ receives at least $\tau-2f=f+1$ records from correct storage objects that have participated on the providing set of each effective read. As proved in Lemma 10, $t\geq f+1$ is enough to satisfy strong accuracy when using DepSky-CA algorithm. Moreover, this limitation does not change the lower bound of Lemma 5, which means that $\tau\geq 3f+1$ is also enough to satisfy completeness in our model. ∎

As mentioned in Section 7.1, readers can sign their read requests for any value (i.e., generic signatures) or for specific values. Non-fast reads can leverage the latter to allow the system to protect against faulty objects using signed read requests to record reads from other values than the one intended by the reader. It contributes to reduce the lower bound of strong accuracy and makes easier to support it with completeness.

Lemma** 11****.**

Applying Algorithm 1 to DepSky-CA protocol with specific signed read requests satisfies strong accuracy with $t~{}\geq~{}1$.

Proof.

Let us assume registers follow DepSky-CA protocol [7] with two communication rounds in read operations. If readers learn, in the first communication round, the label of the value they can effectively read and use it to sign the read request specifically for that value, faulty objects will never create correct records of these readers and that value. Additionally, no read operation will result in correct records for more than one data value, and every read operation results in the creation of correct records in at least $n-f$ objects. As a result, $t\geq 1$ ensures that auditors will only create evidences for the readers that have effectively read that value by sending specific signed requests to the storage objects. ∎

Theorem** 7****.**

Applying Algorithm 1 to DepSky-CA protocol with specific signed read requests satisfies both completeness and strong accuracy with $\tau\geq 2f+1$.

Proof.

Let us assume registers follow DepSky-CA protocol [7] with two communication rounds in read operations and signed read requests for specific values. Assuming $\tau\geq 2f+1$ and based on Lemma 1, any auditing quorum $A$ receives at least $\tau-2f=1$ record from correct storage objects that have participated on the providing set of each effective read. As proved in Lemma 11, $t\geq 1$ is enough to satisfy strong accuracy when using DepSky-CA algorithm with specific signatures. Moreover, this limitation does not change the lower bound of Lemma 5, which means that $\tau\geq 2f+1$ is also enough to satisfy completeness in our model. ∎

A practical consequence of Theorems 6 and 7 is that DepSky-CA protocol [7] would require at least $n~{}\geq~{}5f+1$ (without signed reads) and $n~{}\geq~{}4f+1$ (with signed reads for specific values) to support strong auditability.

8 Final Remarks

This paper defined the notion of auditable registers, their properties, and established tight bounds and impossibility results for auditable storage emulations in the presence of faulty storage objects. Our system model considered read-write registers that securely store data using information dispersal and support fast reads. In such a scenario, given a minimum number $\tau$ of data blocks required to recover a value from information dispersal schemes and a maximum number $f$ of faulty storage objects (1) auditability is impossible with $\tau\leq 2f$; (2) when fast reads are supported, $\tau\geq 3f+1$ is required for implementing weak auditability, while stronger auditability is impossible; (3) signing read requests overcomes the lower bound of weak auditability; and (4) totally ordering operations or using non-fast reads can provide such strong auditability.

The system model considered in this paper is strongly grounded on practical systems deployed in multi-cloud environments(e.g., [2, 7, 28]). As future work, it would be interesting to study how our results will change if considering different models, such as server-based (where base objects can run protocol-specific code and communicate with each other) and synchronous systems.

Acknowledgements.

This work was partially supported by the Fundação para a Ciência e a Tecnologia (FCT, Portugal), through the LASIGE research unit (UIDB/00408/2020 and UIDP/00408/2020) and the IRCoC project (PTDC/EEI-SCR/6970/2014), and by the European Commission, through the DiSIEM (H2020-IA-700692) project.