Verifiable Manufacturing Using Blockchain

TL;DR

This paper introduces a blockchain-based framework for verifiable manufacturing processes, adapting verifiable computing techniques from cloud computing to ensure trustworthiness in physical production through cryptographic proofs and blockchain validation.

Contribution

It develops a novel method linking physical manufacturing processes to digital cryptographic representations, enabling verifiable computation in manufacturing via blockchain integration.

Findings

Successful implementation on Hyperledger Fabric

Demonstrated cryptographic verification of manufacturing processes

Provided a feasible approach for trustless manufacturing verification

Abstract

We propose a blockchain-based solution for enabling verifiability of manufacturing processes. We base our solution on the methodology of verifiable computing which, originally developed for cloud computing, enables clients to outsource computations to more powerful servers without the need to trust that the server correctly performed desired computation. Verifiable computing accomplishes this by enabling the client to generate cryptographic objects that the server must use to produce a cryptographic proof that verifies the correctness of results. The black box nature of servers in cloud computing is analogous to that of the manufacturing processes of an upstream manufacturer. In this work, we develop a one-to-one correspondence between physical processes and their digital representations as state sequences which is needed for the implementation of verifiable computing. Because direct application of verifiable computing in this case would be computationally prohibitive, we introduce a blockchain to provide a computationally feasible methodology for verifiable computing applied to physical processes. We implement and show the results of our implementation on a proof of concept, developed on Hyperledger Fabric.

Equations

$$\text{s}=\{s_0,s_1,\dots ,s_n\},$$

$$\text{s}=(s_0,a_0),\dots ,(s_n,a_n)$$

Full text

1 Introduction

The industry-wide smart manufacturing initiative known as Industry 4.0, seeks to unify the physical with the digital not only within the factory but also the supporting supply chains outside the factory. This is generally being accomplished through the adoption of technologies such as the Industrial Internet-of-Things (IIoT), embedded devices, cyber-physical systems, Internet Protocol (IP) technologies, etc. [1]. A core goal of Industry 4.0 is to create interconnected systems that enable more dynamic information and work flows in contrast to traditional supply chains, with static, one-way flows.

A prerequisite in achieving the goals of Industry 4.0 is the digitization of the factory, for which there exist various proposals (such as Manufacturing Execution Systems or Enterprise Resource Planning systems). However, while digitizing the factory is necessary, it is not sufficient because dynamic interconnected systems, especially between multiple parties, require mutual trust. Current solutions to digitization for factory automation, to the best of the authors’ knowledge, focus on a single organizational settings. Moreover, many of the solutions seek to provide or increase trust within Levels 3-5 of the hierarchy of industrial automation (see Fig. 1), where the available computational resources are that of the cloud. However, ensuring trust at the lower Levels 1 and 2 is more beneficial to the overall hierarchy because that is where actual physical transformations are applied to manufactured items. However, the lower levels of are characterized by computationally-constrained embedded devices where, in many cases, logging is the greatest extent to which trust can be increased by current solutions.

The desire for trust in the manufacturing process is similar to the desire for trust in outsourced computations carried out by third-party cloud service providers. Currently, one must fully trust that the third party properly carries out the computation [2] and this is not ideal for a number of reasons. For example, even if the third party service provider is completely trustworthy, there is a non-zero probability that the service provider may be compromised. A less malicious and more likely possibility is the introduction of errors into the outsourced computation. In both cases, one cannot definitively show that the computation was carried out correctly. Verifiable computing seeks to address this by providing a cryptography-based methodology that enables the third party to provide, along with the computation itself, a cryptographic proof that the computation was indeed correctly computed. This way, the originator of the computation need only trust the cryptographic machinery behind the generation of the proof. Importantly, the computational work required for verifying a computation should be much smaller than the actual computation [3].

At a high level, verifiable computing is typically concerned with the following interaction between three parties. A client specifies the function $f$ to be computed and provides the input data, denoted $x$. A server computes $f(x)$. Finally, a verifier checks the correctness of the result, i.e., that $y=f(x)$. A verifiable computing scheme enables clients to generate the cryptographic objects that both the server and the verifier use to convince the client that the computation was carried out correctly. In typical settings considered in verifiable computing, the function $f$ and the input $x$ to be verified differ with every instance of the problem. This reflects the typical workload encountered in a cloud computing setting, i.e., many singular computations from different users. Workloads found in a manufacturing setting, however, consist of repeated applications of the same function, i.e., some physical transformation $f$, to many identical but uniquely identifiable instances of an input $x_{i}$, where $i$ is within a finite set of possibilities. A direct application of verifiable computing to the manufacturing setting is infeasible since a cryptographic proof would be generated for each product on a manufacturing line. Each proof, while not identical, due to the entropy, would be functionally redundant since each proof verifies the same function on the same input. Generating verifiable proofs for each product with identical specifications is computationally wasteful, adding possibly intolerable latency to the manufacturing process and unnecessarily increasing the storage requirements by retaining a redundant proof for each manufactured product.

In this work, we introduce a blockchain-based verifiable computing system for manufacturing processes. Two main components comprise the system: verifiability at the field device level and a permissioned blockchain network that reduces the computational cost of verification at the field device level. Verifiability at the field device level is achieved by ensuring verifiability of controllers, i.e., devices in the control level of the hierarchy of industrial automation. Blockchain is used to enable the use of a single proof for verifying all items manufactured according to the same specifications. We present an application of the idea in the form of a proof ofconcept (PoC). We use Hyperledger Fabric [4], a Go-based framework for permissioned blockchains, to implement the blockchain network. For the verifiable computing component, we use gnark, a Go-based library that provides an API-based approach to generating polynomial circuits.

The literature has explored many systems that implement verifiable computing including those that are based on secure hardware [5], verifying specific functions [6], auditing [7], and cryptography and complexity theory [8]. The topic of applying blockchain to industrial systems is covered in [9, 10, 11, 12]. To the best of the authors’ knowledge, the literature has not explored applying verifiable computing to manufacturing processes.

The rest of this paper is structured as follows. Section 2 discusses a theoretical framework for verifiable manufacturing. Section 3 details the implementation of our framework in a PoC. Section 4 is the conclusion.

2 Verifiable Manufacturing

Verifiable computing provides a cryptography-based framework for ensuring that, given a computation $f$ on some data $x$, an accompanying verifiable proof 555Also known as a transcript $\sigma_{y}$ can be generated by the server such that any third party can use $\sigma_{y}$ to verify that $y=f(x)$. In this section, we explain how the verifiable computing framework, originally developed for cloud computing, can be adapted and applied to industrial manufacturing processes.

Verifiability of manufacturing processes is desirable for many of the same reasons as in cloud computing. It is often the case that manufacturing companies have no visibility into the manufacturing processes employed by their suppliers. Suppliers are essentially black boxes that provide a product that conforms to a specification. A similar situation exists in cloud computing, where clients have no visibility into the operations of the servers responsible for their outsourced computations. Errors in industrial automation typically have an outsize impact as they lead to physical, as opposed to software, faults. For example, small errors in configuration, nearly impossible to detect, can be extremely costly for downstream OEMs (original equipment manufacturers); for this reason, downstream OEMs typically expend additional effort to test upstream products, in order to ensure specifications.

To introduce verification of physical manufacturing processes, we introduce verifiability at Levels 1 and 2 of the hierarchy of industrial automation (see Fig. 1), since it is within these layers where actual physical transformations are carried out. At these levels, devices are usually computationally constrained, and it is difficult to apply verifiable computing directly. In the rest of the section, we show how verifiable computing can be applied in the industrial context.

We begin by defining a verifiable computing scheme, after which we show how that scheme can be applied to control and field devices, and finally we discuss how a permissioned blockchain can be used to make verifiable proofs practical in a factory automation setting.

2.1 Verifiable Computing

We begin with the following definition.

Definition 1** ([13])**

A verifiable computing scheme consists of the following (probabilistic, polynomial-time) algorithms:

$\textrm{KeyGen}(1^{\lambda},f)\rightarrow(\textsf{sk,vk,ek})$: a setup algorithm that, given a security parameter $\lambda$ and a specification of the function $f$, generates a secret key sk, a verification key vk, and a public evaluation key ek encoding $f$. 2. 2.

$\textrm{ProbGen}(\textsf{sk},x)\rightarrow(\sigma_{x},\rho_{x})$: encodes the problem data by taking the data $x$ and the secret key sk and returns the encoded data $\sigma_{x}$ and the decoding value $\rho_{x}$. 3. 3.

$\textrm{Compute}(\textsf{ek},\sigma_{x})\rightarrow\sigma_{y}$: computes a proof $\sigma_{y}$, an encoded version of the output $y=f(x)$ using the evaluation key ek. 4. 4.

$\textrm{Verify}(\textsf{vk},\rho_{x},\sigma_{y})\rightarrow\{y,\bot\}$: given the verification key vk, a decoding value of the data $\rho_{x}$, and the encoded output (verifiable proof) $\sigma_{y}$, the verification returns $\bot$ if $y\neq f(x)$ and returns $y$ if $y=f(x)$.

A verifiable computing scheme enables a client to outsource computations to an untrusted server. The overall process is illustrated in Fig. 2. The prover first 1) generates the necessary cryptographic keys by executing KeyGen$(1^{\lambda},f)$, which returns the secret (sk), verification (vk), and evaluation (ek) keys. Next, the prover encodes the problem data by 2) running ProbGen$(\textsf{sk},x)$ using the secret key sk and returns the encoded problem data $\sigma_{x}$ and the decoding value $\rho_{x}$. The verifier then sends the function 3a), the encoded problem data 3b), and the evaluation key 3c) to the prover who computes the desired computation $f(x)$ and executes Compute(ek,$\sigma_{x}$) returning the encoded output $\sigma_{y}$ 3d) that constitutes the cryptographic proof, which 4) is sent to the verifier. Note that a verifiable computing scheme is known as a “privately verifiable computing scheme” if $\textsf{sk}=\textsf{vk}$. Otherwise, it is known as a “publicly verifiable computing scheme”. Publicly verifiable schemes enable a client to publish the verification key where any third party possessing $\rho_{x}$ and vk can verify the correctness of an outsourced computation.

Verifiable computing schemes can be implemented using a variety of cryptographic technologies such as: interactive proofs [14], probabilistically checkable proofs [15], fully homomorphic encryption [16], and argument systems [17]. Early work in implementing verifiable computing using the aforementioned technologies were not practical due to their high computational costs, but recent technologies such as [8] and [18] have made verifiable computing practical.

In practice, the most important step in implementing verifiable computing is the translation from a human-readable programming language to its backend equivalent. This translation process is split into a frontend and backend phase, similar to how traditional computer code is compiled from a human-readable language to an intermediate representation (IR) in the frontend and from the IR to a platform-specific form in the backend. For example, [19] and [20] provide not only advances in implementing verifiable computing schemes but also toolchains that convert C and Java programs, respectively, into arithmetic circuits, whose details we describe later.

2.2 Verifiability for Physical Processes

Devices in the field level, or “field devices”, broadly refer to devices such as CNC (computer numerical control) machines, machining tools, actuators, valves, sensors, etc. They often have limited or no compute and are used to perform physical transformations on a production floor. Field devices possess a finite number of atomic operations, each of which can be modeled as a state in a finite state machine [21]. As such, a sequence of states, or “state sequence”, corresponds to a field device effecting a physical transformation, i.e., there is a one-to-one relationship between a state sequence and a physical transformation.

Field devices are driven and coordinated by specialized industrial computers, known as PLCs (programmable logic controllers), that are designed for rugged industrial environments and for controlling electromechanical devices. PLCs are examples of devices in the control level, or “control devices”, responsible for coordinating field devices. It is necessary for field devices to be controlled by control devices because, on a production floor, field devices need to be precisely coordinated with other field devices to effect physical transformations. Without control devices, field devices would need to make a connections to every other field device. Moreover, field devices do not possess the computing power to be able to coordinate with other field devices since that would require, at a minimum, a real-time enabled kernel.

For these reasons, while a state sequence is equivalent to a physical transformation, the state transitions occur on the PLC and not on the field device. As a PLC transitions through the states of a state sequence, it instructs the corresponding field device to perform an operation. Concurrently, or after the operation is completed, the field device returns information to the PLC such as feedback on the current state of the field device, whether the field device encountered an error performing the operation, the configuration of the field device, etc. The controller uses this information to determine whether or not to transition to the subsequent state.

Thus, enabling verifiability of a manufacturing process is equivalent to ensuring that all physical transformations are made verifiable. Consequently, state sequences must be made verifiable due to their one-to-one correspondence to a physical transformation. Note that since state transitions occur on a PLC and not within a field device, a state sequence can comprise multiple physical transformations from multiple field devices. Moreover, the PLC itself must be made verifiable in order for a chain-of-trust to be established, however, this is outside the scope of this paper.

2.3 State Sequence Circuits

State sequences are digital representations of physical transformations within a manufacturing setting. Consequently, physical manufacturing processes can be made verifiable by making state sequences verifiable. To this end, we begin by detailing the modeling of state sequences. Since field devices can be modeled as finite state machines, it follows that state sequences can be modeled as sequences of a finite number of integers,

[TABLE]

where $s_{i}\in\mathbb{Z}$ for $i=0,\dots,n$, and $n$ denotes the total number of states in the state sequence. However, representing a state sequence only as a series of integers is insufficient since, in many cases, additional information from the field device that is not inferred from its current state must also be verified. For example, it is often necessary, at the beginning of a manufacturing run, to ensure that a field device is operating with the correct configuration. Field devices, in many cases, can also return this information as a string, which can represent a configuration ID or a hash of the configuration. Note that auxiliary information is only useful at certain stages of a field device’s operation. That is, auxiliary information should be coupled with the states of a field device. Thus, it is natural to define a state sequence to be a series of tuples, as in the following.

Definition 2

A state sequence is a digital representation of a physical transformation directed by a PLC and is represented as a sequence of tuples,

[TABLE]

where $a_{i}$, the auxiliary data, can be either an integer, a string, or empty for any $i=0,\dots,n$.

Verifying State Sequences

State sequences must be converted to arithmetic circuits in order to use the machinery necessary to generate verifiable proofs. Arithmetic circuits are used to convert basic arithmetic equations into a series of logical tests such that a value satisfying an arithmetic equation is equivalent to the logical test being satisfied [2]. In the manufacturing setting, downstream OEMs send the specifications of their product to their upstream manufacturers which usually generates the PLC program to be run. Therefore, downstream OEMs, in most cases, are only concerned that an agreed-upon state sequence was executed. To verify this, we can implement a set-membership logical test for the state sequences and auxiliary data, meaning that the $f$ in a verifiable computing scheme can consist of a series of set-membership tests for integers and strings. For a tuple $(s_{i},a_{i})$, the state component, being an integer, is straightforwardly implemented in an arithmetic circuit. The only difficulty is in the comparisons of the auxiliary information component of a state tuple, when $a_{i}$ is a string. Computationally, this can be remedied by obtaining an integer representation of the string $a_{i}$, from which we can reduce the check for equality of strings to the equality of integers.

2.4 Blockchain for Verifiable Proofs

The main issue preventing verifiable computing from being applied to manufacturing is the prohibitive computational cost, in both compute and storage, associated with generating a verifiable proof for each manufactured item. This is because, contrary to typical workloads in cloud computing, workloads in manufacturing, i.e., within a set of items of the same specification, consist of repeated applications of a physical transformation to identical but uniquely identifiable inputs. A straightforward application of verifiable computing is impractical since it would result in the generation of a verifiable proof for every item. We note that, while each generated verifiable proof is not bit-for-bit identical, they are, however, functionally identical since they all verify that the same physical transformation was applied to the same input; the only difference between each verifiable proof is the entropy used.

To solve this problem, we introduce a blockchain solution enabling the reuse of a single verifiable proof for all items of the same specification. While a verifiable proof can be reused without the use of blockchain if the verifiable proof and its associated cryptographic keys are properly distributed to participants, a verifiable proof by itself does not enable the verifiability of manufacturing processes. Assuming that the verifiable proof is in some trusted shared location or distributed to the verifier, the prover, i.e., PLC, could send a copy of the state sequence to the verifier. However, this would not implement important aspects of verification, such as immutable records of an attempt at verification of a physical transformation applied to a physical object and subsequent results, and these aspects are certainly possible using a blockchain solution. Moreover, without a common network built on top of blockchain, the possibility exists that the manufacturer would be able to equivocate its results by sending different verifiable proofs to different parties. For these reasons, blockchain is a necessary component for the application of verifiable computing to physical manufacturing processes.

Our solution relies on embedding verifiable proofs within smart contracts. We denote such smart contracts as verification contracts. Smart contracts are programs that are stored and run on the blockchain; they have their own address and are invoked by sending transactions to their address; they are stored on and executed by every full node participating in the blockchain network. Combining a verifiable proof and a smart contract obviates the need to manage keys associated with a verifiable proof and the need to trust that all participants have received the same verifiable proof.

Figs. 3 and 4 illustrate the general scheme. As shown in the figures, smart contracts are broadcast to the network by distributing the source code to each full node where they are checked for validity and compiled. In the case of verification contracts, a smart contract contains logic implementing a verifiable computing scheme that each full node compiles locally, as shown in Fig. 3. Thus, each full node contains a verifiable proof that is functionally but not bit-for-bit identical, since different entropy was used in their generation, to verifiable proofs generated from the same verification contract compiled on other full nodes.

Given the same input, the verifiable contracts on all full nodes return the same result. The verification contract is trusted throughout the blockchain network since its source code was distributed to all participants. Finally, since the verification contract is a smart contract, all attempts at verification and the subsequent results are memorialized on the immutable blockchain. This is shown in Fig. 4 where a request for verification is first sent to the network and also memorialized. The nodes read the request from the blockchain and proceed to run the verification contract. The results, which must agree through consensus, are written back to the blockchain.

2.5 Overview of Scheme

In Fig. 5, we present a schematic depicting how a physical transformation applied to a manufactured product is verified and how the blockchain is used. The PLC program is 1) loaded onto the PLC which begins instructing the field device. Then the product is 2) fed to the field device. The field device 3) applies the physical transformation to the manufactured product; simultaneously, the field device send feedback to the PLC on its operating state and any other auxiliary information. When the state sequence is complete, the PLC 4) forwards the state sequence to the network for verification by invoking the verification contract. Only the results of verification and a unique identifier for the manufactured item are 5) written onto the blockchain. The item then 6) progresses through the manufacturing line to the next field device.

3 Proof of Concept

We implement a proof of concept (PoC) of a verifiable factory automation system backed by a permissioned blockchain network, where we demonstrate how field devices can be made verifiable through the verifiability of control devices. The focus of the PoC is to demonstrate the verifiability of manufacturing processes in a factory automation context by verifying the state sequences representing physical transformations and not to demonstrate the interaction between the field device and the controller. Our PoC consists of three main components: the PLC, the verifiable subsystem, and the blockchain network. We discuss the implementation of these components in the following.

3.1 PLC

The PLC is the control unit for a series of physical transformations carried by one or more field devices. In our PoC, they are emulated using a Raspberry Pi because of their increasing use as PLC replacements [22], due to the growing virtualization of their capabilities and responsibilities [23]. The Raspberry Pi runs the current Ubuntu LTS (20.04) as its operating system. We used pigpio [24], a C library that provides the low-level capabilities for communicating with GPIO, to develop custom code that uses GPIO to communicate to a CNC milling machine that we used as a field device. We used the Raspberry Pi to connect to a CNC milling machine to generate sample state sequences that are representative of situations encountered in factory automation.

3.2 Verifiable Subsystem

The verifiable subsystem is responsible for verifying state sequences and is implemented using smart contracts by embedding smart contracts with logic that implements a verifiable proof. In our PoC, we choose to implement a verifiable computing scheme using zk-SNARKs (Zero Knowledge Succinct Non-interactive ARguments of Knowledge) due to its many real-world implementations; zk-SNARKs are an instance of non-interactive argument systems and consist of three probabilistic polynomial-time algorithms, defined below.

Definition 3** ([13])**

A zk-SNARK consists of the following probabilistic, polynomial-time algorithms:

$\textsf{Setup}(1^{\lambda})\rightarrow(\textsf{crs},\textsf{vrs})$: a setup algorithm that, given a security parameter $\lambda$, generates a common reference string crs. 2. 2.

$\textsf{Prove}(\textsf{crs},u,w)\rightarrow\pi$: an algorithm that, given a common reference string crs, a statement $u$ (to be proven), and a witness $w$ (a private input) produces a proof $\pi$. 3. 3.

$\textsf{Verify}(\textsf{vrs},u,\pi)\rightarrow\{0,1\}$: given a verification state, a statement $u$, and a proof $\pi$, either accepts or rejects the validity of the statement.

A witness is usually an auxiliary piece of information necessary to convince the verifier of the truth a statement. In manufacturing, the witness is the correct sequence of state transitions, i.e., the correct specification that the manufacturer must know.

For implementation, we use gnark, an open source Go library for zk-SNARKs that exposes a high-level API for programming arithmetic circuits [25]. Gnark contains sub-libraries that handle the frontend and the backend phases of constructing arithmetic circuits. The frontend library provides an API for describing mathematical statements that can be converted into arithmetic circuits. The backend APIs compile the objects created by the frontend APIs into two particular zk-SNARK constructions: R1CS [26] and PlonK [27]. We use the R1CS constructions for our zk-SNARKs due to its superior performance, evidenced by its widespread use. One useful design of gnark is that the library is exposed as an API. This is crucial for tightly integrating the verifiable proof logic with the chaincode infrastructure since the Golang toolchain only needs to import the gnark library source files and no additional resources outside the Golang toolchain, such as shared libraries. Any Go objects resulting from the verifiable proof logic can be used directly in the chaincode. The verifiable proofs of state sequences are implemented in chaincodes using gnark are described as follows.

3.2.1 Circuit Compilation

First, the set-membership logical test for the state sequences and auxiliary data must be implemented as arithmetic circuits. This is a three-step process in gnark. The first step consists of implementing a struct whose member variables correspond to the states of the state sequence. The member variables must have the type frontend.Variable in order to be visible to gnark. The second step consists of defining a series of constraints using the variables defined in the previous step. In gnark, this must be done by providing an implementation of the receiver function Define over the struct defined in the previous step. The logic describing the set-membership logical test is implemented within the body of Define. We note that Define is not explicitly used within the codebase, rather, it is used by the gnark library internally. Finally, the circuit is compiled by invoking the function Compile, which takes as its input an instance of the circuit, the choice of elliptic curve, and the choice of zk-SNARK backend and returns a compiled constraint system.

3.2.2 Key Setup

After the set-membership logical test is implemented, the corresponding keys necessary for the proof generation and verification needs to be generated. This is done in gnark by calling the function Setup which takes as input a compiled constraint system and returns an evaluation key and a verification key.

3.2.3 Prove

The final step is in generating the actual verifiable proof. This is done in gnark by calling the function Prove, which takes in the compiled constraint system, the private key and a witness containing the expected state sequence and returns a proof. After the verifiable proof is generated, it must be stored locally on each full node in the blockchain network. While the chaincode API does not allow, by default, storing data local to a chaincode, one workaround is to exploit the fact that chaincodes run in their own VMs (Docker container) and serialize the verifiable proof and the verification key onto both the local filesystem within the chaincode VM and the blockchain.

3.2.4 Verify

When the verification contract is invoked, it loads the verifiable proof and key from the local storage, verifies the state sequence and sends the result onto the orderer.

3.3 Blockchain Network Architecture

Permissioned blockchains mainly differ from unpermissioned blockchains in that permissioned blockchains require participants to be trusted before they are allowed to participate in the network. This model of trust is identical to that of industrial settings and for this reason permissioned blockchains are well-suited for implementing a factory automation blockchain.

We implement the permissioned blockchain network using Hyperledger Fabric [4], a Docker-based permissioned blockchain framework written in Go. Nodes in the network are Docker containers that communicate with each other via conventional internet protocols. The Fabric library compiles into two main binaries: the orderer and the peer binaries. The orderer binary contains the ordering service, whereas the peer binary contains the functionality to run a full node. Blockchain functionality is implemented by providing the functions from the chaincode interface in Fabric. Chaincodes are compiled into binaries which are then run on peers. The separation of the peer and chaincode executables isolates the node from any errors in the smart contract.

The architecture of the blockchain network is illustrated in Fig. 6 and consists of an orderer, two full nodes, and a Raspberry Pi (RPi). The dashed blue box signifies the fact that the full node and the RPi (PLC) belong to the same organization. We describe each in the following.

3.3.1 Full nodes

There are two full nodes in the factory automation blockchain network represented in purple in Fig. 6. Full nodes store a full copy of the blockchain. More importantly, each full node stores a copy of, compiles, and executes verification contracts. The results from each full node are sent to the orderer for consensus.

Full nodes represent participants in a factory automation network that need to ensure that an industrial process was executed according to specification. For example, a full node can be run within a factory as an edge node that ensures that internal quality controls are met. Another example of a participant that may run a node is a downstream producer that needs to ensure that incoming products are indeed manufactured according to specification.

3.3.2 Orderer

In permissoned blockchains, an orderer node orders the transactions in the network, thereby providing consensus. In the PoC, the orderer node is implemented using the conventional application of Fabric libraries.

3.3.3 PLC

The PLC is implemented using a Raspberry Pi. It controls field devices and invokes the verification contracts. Its implementation details have already been discussed.

3.4 Implementation and Discussion

In the PoC, the process consists of identifying an incoming part by scanning its barcode, and machining the part in a CNC machine tool using a specific input file and machine configuration. The Raspberry Pi runs 64 bit Ubuntu 20.04 emulated the functionality of a PLC. The barcode scanner and CNC milling machine are connected to the PLC and act as field devices. During machining, the PLC uses gpio pins to monitor several status flags provided by the machine tool such that faults in the machining process could be detected.

An application developed in C emulates a PLC program implementing a finite state machine (FSM) for sequencing individual steps of the physical manufacturing process. Valid state sequences derived from the FSM were used to generate verification proofs, the results of which are presented in Fig. 7. The state sequence consists of the following states: an initial state, a read-file state with an expected file hash, a read-config state with an expected success code, a scan state, an inspection state, and an end state with a verification result code.

In the figure, one can see both a failed run and a successful run. In the first case, verification results in a failed state sequence; in the second, the state sequence is successfully verified. In the graphic, red boxes indicate where in the sequence (finite state machine) failures have been encountered. The prototype demonstrates that unexpected changes in manufacturing processes, previously difficult to verify, can now be verified and memorialized in a trusted manner using blockchain. The PoC therefore shows that blockchain can make verifiable computing practical for physical processes within a manufacturing setting, illustrating that physical processes can be made verifiable through blockchain-based verifiability.

In this work, we determined the state sequences corresponding to specific outcomes manually. This was only possible because the physical process was very simple and computing the set of valid state sequences for an arbitrary PLC program controlling a complex process was outside the scope of this work. As discussed previously, this work assumes that control and field devices are trusted; future work will work to enable verifiability at this level.

4 Conclusion

This work considered the application of a blockchain-based verifiable computing scheme to physical manufacturing processes. We adapted verifiable computing, developed for abstract mathematical objects, to physical processes by establishing a one-to-one relationship between physical transformations carried out by field devices to the state sequences that direct them on a PLC. The verifiability of physical processes in and of itself is not enough to enable the verifiability of manufacturing processes since a direct application of verifiability would be computationally intractable. To this end, we introduced a blockchain-based solution consisting of embedding verifiable proofs in smart contracts. The public nature of smart contracts within blockchain networks makes verifiable proofs trusted, enabling reuse. The underlying blockchain acts an immutable record of the verification of manufactured items that have undergone some physical transformation. We implemented a proof of concept based on Hyperledger Fabric demonstrating the viability of our scheme.