Embedding Digital Signature into CSV Files
Using Data Hiding

CSV is a file format widely used for tabular data. It is a plain text, where a line makes a record and items in a record are separated by commas. Fig.1 shows an example of a CSV file where the data has one header and two records, each with four fields. Each field, such as H1 or Hello, may be enclosed by double quotes.

In actual open data, the format of CSV files is not necessarily consistent. According to Mitlöner et al. [13], only 88% of open data use commas as field separators and 10% use semicolons. Therefore, there was an attempt to make a standard of the CSV format as RFC [19]. Fig.2 shows the syntax description of a CSV file proposed in RFC4180 written in ABNF [5]. According to the standard (RFC 4180), a CSV file is composed of one or more records delimited by CRLFs. The file may have a header line, but there is no way to determine whether or not the first line is the header line. A record (and a header) has multiple fields, where a field is either an escaped or a non-escaped string. An escaped string is a string enclosed by double quotes, where the string inside may contain commas, CRs, LFs, and double quotes (a double quote is escaped by one more double quote). A non-escaped string can contain any character besides commas, double quotes, CRs, and LFs.

A digital signature is a robust cryptographic mechanism that guarantees the authenticity and integrity of a digital document [18, 8] . It harnesses a blend of mathematical algorithms and cryptographic keys to achieve a high level of security, providing reassurance in the digital realm.

The core principle behind a digital signature involves using a public-key cryptography system [18]. The signer possesses a private key, which is kept confidential, and a corresponding public key, which can be freely distributed. When a document is signed, a mathematical hash function is applied, generating a unique digital fingerprint. This fingerprint (a hash value) is then encrypted with the signer’s private key, creating the digital signature.

The recipient of the signed document can verify its authenticity using the signer’s public key. The recipient obtains the original hash value by decrypting the signature with the public key. They can then independently calculate the hash of the received document and compare it to the decrypted value. If both values match, it confirms that the document originated from the claimed signer and has not been tampered with since the signature was applied.

Digital signature streamlines workflows by enabling secure electronic document signing and verification, eliminating the need for physical documents and manual processing [17]. It is also used to maintain the authority and integrity of open data. Wong et al. proposed a system architecture for signing open data [22]. Their proposal includes a public key infrastructure and HTTP servers that provide the data. However, they did not discuss how the signature is attached to the data file; it may be assumed that the provided data is in a format that can involve a signature, such as xlsx.

Unfortunately, a CSV file cannot include a signature because it is a plain text file with no inner structure. Therefore, even if we calculate a signature for a CSV file, we need to deliver it separately, which may reduce the value of the signature.

The proposed method embeds arbitrary binary data into a CSV file. To do that, we exploit the redundancy of quoting a field. As shown in Fig.2, a field can be either an escaped string or a non-escaped string when the string does not involve special characters (double quote, comma, CR, and LF).

Consider a CSV file has $N$ rows and $M$ columns¹¹1The data in a CSV file do not need to be in a single table. However, we assume that it contains a rectangular table here for simplicity; the following discussion applies to non-rectangular data..

Here, $x_{ij}$ is a character string, including a null string, without enclosing double quotes. Then we regard all the fields as a sequence, $x(1),\ldots,x(K)$, where $x_{ij}=x((i-1)M+j)$ and $K=NM$. We consider a function to determine whether a field needs to be escaped:

If $\mathrm{noesc}(x)=0$, it means that the string $x$ should be enclosed by double quotes. Otherwise, $x$ may be enclosed by double quotes or it may be used without double quotes. Therefore, the fields where $\mathrm{noesc}(x)=1$ can be used for a one-bit payload. The total payload can be calculated as $P(K)$, where

$P(k)$ is the number of bits we can embed into $x(1),\ldots,x(k).$

Next, we define two functions to calculate the string representation of the data. The first is to put the double quotes in only the needed fields.

Here, $\mathrm{Con}_{\alpha}s_{i}$ means concatenation of strings $s_{1},s_{2},\ldots$ using delimiter $\alpha$, as follows.

where $\circ$ means the string concatenation operator. $\mathrm{esc}_{0}$ is an escape function defined as follows.

The second function is to embed data into the CSV string. First, we consider the data to be embedded as follows.

Then, the function is defined as follows.

The function $\mathrm{esc}_{1}(x)$ encloses $x$ with double quotes when $x$ involves special characters or the bit 1 is embedded. Fig. 3 shows an example of a CSV file with a hidden message. This CSV file has nine fields (three rows, three columns), but the first field of the second row ("Hello,world") cannot be used as a payload because it contains a comma.

Consider a CSV file in which each field may or may not be enclosed by double quotes. Then, consider a matrix made by splitting the input CSV file using CRLFs and commas.

Here, $y_{ij}$ may or may not be enclosed by double quotes. For example, when the input CSV file contains

"H1",H1,"N1" CRLF "Hello,world","green",3.0,

then the comma-split data is

Then, we define two functions, $\mathrm{strip}(y)$ and $\mathrm{extract}(y)$, as follows.

Here, $\mathrm{strip}(y)$ is a function that trims the enclosing double quotes. The function $\mathrm{extract}(y)$ is a function to extract the hidden bit from a field, which returns one of 0, 1, and $\epsilon$. The value $\epsilon$ means that the field does not contain a hidden bit.

Using $\mathrm{extract}(y)$, we can extract the hidden message from $Y$ by concatenating all of $\mathrm{extract}(y(1)),\ldots,\mathrm{extract}(y(K))$ and removing all $\epsilon$ from the sequence. We denote this sequence as $\mathrm{extract}(Y).$

First, we consider stripping all unnecessary double quotes from the CSV file:

Applying strip to $Y$ removes all enclosing double quotes for all fields.

When calculating a signature, we need a pair of the public and private keys, denoted as $\kappa_{\mathrm{\scriptsize pub}}$ and $\kappa_{\mathrm{\scriptsize priv}}$, respectively.

Then, we insert a signature and validate it as follows. Let a hash function be $H(s)$ that returns a fixed-sized bit sequence, where $s$ is a string. Let an encryption function be $E(\mathbf{b},\kappa)$, which receives a bit sequence $\mathbf{b}$ and a key $\kappa$, then returns a bit sequence with the same length as $\mathbf{b}.$ When we have data $Y$ from a CSV file, we calculate the signature $\mathbf{s}$ as

Then, we generate the embedded CSV file as

Next, when we receive a signed CSV file, we calculate a matrix $Y^{\prime}$ by splitting the CSV files by CRLFs and commas. Then, we extract the embedded signature as

Now we decrypt $\mathbf{s}^{\prime}$ and compare it to the hash extracted from the stripped CSV file. If

then the CSV file is validated.