Helion: Enabling a Natural Perspective of Home Automation

TL;DR

Helion is a framework that models realistic home automation scenarios based on user routines, aiding security research by providing natural, valid event sequences that reflect actual user behavior in smart homes.

Contribution

Helion introduces a novel approach to generate natural home automation scenarios by identifying semantic patterns in user routines, improving security system design and evaluation.

Findings

Helion's scenarios are validated as reasonable and valid by external evaluators.

Generated security policies with Helion require less effort than existing methods.

Empirical analysis confirms the naturalness hypothesis with a large dataset.

Abstract

Security researchers have recently discovered significant security and safety issues related to home automation and developed approaches to address them. Such approaches often face design and evaluation challenges which arise from their restricted perspective of home automation that is bounded by the IoT apps they analyze. The challenges of past work can be overcome by relying on a deeper understanding of realistic home automation usage. More specifically, the availability of natural home automation scenarios, i.e., sequences of home automation events that may realistically occur in an end-user's home, could help security researchers design better security/safety systems. This paper presents Helion, a framework for building a natural perspective of home automation. Helion identifies the regularities in user-driven home automation, i.e., from user-driven routines that are increasingly being created by users through intuitive platform UIs. Our intuition for designing Helion is that smart home event sequences created by users exhibit an inherent set of semantic patterns, or naturalness that can be modeled and used to generate valid and useful scenarios. To evaluate our approach, we first empirically demonstrate that this naturalness hypothesis holds, with a corpus of 30,518 home automation events, constructed from 273 routines collected from 40 users. We then demonstrate that the scenarios generated by Helion are reasonable and valid from an end-user perspective, through an evaluation with 16 external evaluators. We further show the usefulness of Helion's scenarios by generating 17 home security/safety policies with significantly less effort than existing approaches. We conclude by discussing key takeaways and future research challenges enabled by Helion's natural perspective of home automation.

Tables

Table 1. Table 1. Selection of specific ranges, any time, or not sure options for execution indicators, by number of routines.

Execution Indicator	Specific Range	Anytime	Not Sure
Time-range	155 (56.78%)	107 (39.2%)	11 (4.02%)
Frequency	256 (93.77%)	0	17 (6.23%)
Day-range	59 (21.61%)	186 (68.13%)	28 (10.26%)

Table 2. Table 2. A summary of the ratings by evaluators for the routine comparison study. Percentages are out of 160 ratings in total.

Routine Study (Bigram Generation)
Model Config						N-Gram	Strongly Agree	Somewhat Agree	Somewhat Disagree	Strongly Disagree
	3	50.63%	19.38%	11.87%	18.13%
up	4	69.38%	13.12%	4.38%	13.12%
	3	5.0%	11.87%	15.0%	68.13%
down	4	0.63%	11.87%	19.38%	68.13%
none (from survey)	-	63.75%	25%	3.75%	7.5%

Table 3. Table 3. A summary of the ratings for the sequence generation study. Percentages are out of 160 ratings in total.

Event Sequence Generation Study
Training Data						N-Gram	Strongly Agree	Somewhat Agree	Somewhat Disagree	Strongly Disagree
	3	41.25%	21.25%	15.63%	21.88%
HOME	4	37.5%	25.63%	12.5%	24.38%
	3	43.13%	33.75%	10.63%	12.5%
HOME + Evaluator’s data	4	38.75%	28.75%	16.88%	15.63%

Table 4. Table 4. List of smart home violations, the core problem found by the violations, and the corresponding policies developed from them.

Violation	Problem	Policy	Flavor
- Gas stove on when user away. - Gas stove is on when user is on vacation.	Gas stove is on when user is not at home.	(Pol1) Gas stove should not be on when the user isn’t home.	down, up-down, down-up
- Gas stove is on when smoke has been detected previously.	Gas stove is on after smoke detector detects smoke.	(Pol2) Gas stove should not be on when smoke is detected.	up
- Security camera is taking images when motion is detected. However, the user is home, which justifies motion as well as potentially violates user’s privacy. - Security camera on when user is home. - Security camera is on and taking images when presence sensor detects that user is present at home	Security camera is on when the user is at home.	(Pol3) Security camera should be off when the user is home to preserve privacy.	up, down, up-down, down-up
- Door is opened when user is away, but the user doesn’t receive a notification. - Door is opened when user is in vacation, but user isn’t notified. - Door is opened but the presence sensor detects that user isn’t present at home and user is not notified.	Door sensor senses that the door is open when user is not at home.	(Pol4) User should be notified if the door sensor senses the door is open when the user is away.	up, up-down
- Window opened when user away, but the user isn’t notified.	Contact sensor senses that the window is open when user is not at home.	(Pol5) User should be notified if the contact sensor senses the window is open when the user is away.	up, down
- Water valve closed when fire sprinkler on.	Water valve is closed when fire sprinkler turns on.	(Pol6) Water valve should not be closed if the fire sprinkler is on as a reaction to fire/smoke.	down, down-up
- Air purifier turns off when CO is detected	Air purifier turns off when CO detector detects CO.	(Pol7) Air purifier should not turn off automatically if CO is detected.	down
- Shades/Blinds are opened in the morning, but the user is away. - Shades/Blinds opened in vacation mode.	Shades/Blinds open when user is away.	(Pol8) Window shades should not open when user is not home.	up, down, down-up
- Door is unlocked after gas level is detected to be high or alarm going off, supposedly as a safety measure, but user is away. - Door unlocked in vacation mode. - Door is unlocked state but presence sensor is detecting that user isn’t present at home.	Door is unlocked when user is not at home.	(Pol9) User should be prompted before the door is unlocked automatically for any reason, when user is away.	down, up-down, down-up
- Door stays unlocked even after user leaves home.	Door lock stays unlocked when user leaves home.	(Pol10) Door should lock automatically when mode changes from home to away.	down
- Door remains unlocked when the sleep monitor detects that the user is sleeping.	Door is unlocked when user is sleeping.	(Pol11) Door should be locked when the bedroom sleep monitor detects that user is sleeping to ensure safety.	up-down
- The sleeping monitor detects the user as sleeping, and the garage door is open.	Garage door is open when user is sleeping.	(Pol12) Garage door should be closed when bedroom’s sleep monitor detects that user is sleeping.	up-down
- The induction cooktop is on after the sleep monitor detects that the user is sleeping.	Electric appliance which is a potential fire hazard is on when user is sleeping.	(Pol13) Induction cooktop should not be on when user is sleeping.	up-down
- Garage door opened when user is away. - Garage door opened when user in vacation mode.	Garage door is open when user is not at home.	(Pol14) Garage door should be closed when user is not home.	down, up-down, down-up
- Glass break is detected when user is away but user is not notified. - Glass break is detected in vacation mode but user isn’t notified.	Glass break is detected but the user is not notified.	(Pol15) User should be notified when glass break is detected.	down-up
- Security alarm turned off when smoke is detected and user is away.	Security system turned off when smoke detector detects smoke.	(Pol16) Security alarm should not be off when user isn’t home.	down-up
- Fire sprinkler on when there is no fire.	Fire sprinkler is on for no reason.	(Pol17) Fire sprinkler should only be on when there’s fire detected in the home.	up-down, down-up

Equations

$$\begin{array}{rl}p(e_1^m)& =p(e_1)p(e_2|e_1)p(e_3|e_1^2)...p(e_m|e_1^{m-1})\\ & =\prod _{i=1}^{m}p(e_i|e_1^{i-1})\end{array}$$

$$p(e_1^m)=\prod _{i=1}^{m}p(e_i|e_1^{i-1})\approx \prod _{i=1}^{m}p(e_i|e_{i-n+1}^{i-1})$$

$$H_M(e_1...e_n)=-\frac{1}{n}{\log }_2{P}_M(e_1...e_n)$$

Full text

This paper presents H$\epsilon$lion, a framework for building a natural perspective of home automation. H$\epsilon$lion identifies the regularities in user-driven home automation, i.e., automation that is built from user-driven routines that are increasingly being created by users through intuitive platform UIs. Our intuition for designing H$\epsilon$lion is that smart home event sequences created by users exhibit an inherent set of semantic patterns, or “naturalness” that can be modeled and used to generate valid and useful scenarios. To evaluate our approach, we first empirically demonstrate that this “naturalness” hypothesis holds, with a corpus of 30,518 home automation events, constructed from 273 routines collected from 40 users. We then demonstrate that the scenarios generated by H$\epsilon$lion are reasonable and valid from the end-user perspective, through an evaluation with 16 external evaluators. We further demonstrate the usefulness of H$\epsilon$lion’s scenarios by addressing the challenge of generating security/safety policies for home automation, and specifying 17 security policies with significantly less effort than existing approaches. We conclude by discussing key takeaways and future research challenges enabled by H$\epsilon$lion’s natural perspective of home automation.

1. Introduction

Smart home technology has reached a critical mass, with the global smart home market projected to grow to over $53 billion by the year 2022 (Statista, 2019). This market is primarily driven by the consumer demand for seamless home automation, which not only includes the ability to control smart home devices remotely, but also the flexibility of having devices react to changes in the state of the user or the home. Popular smart home platforms such as Samsung SmartThings (SmartThings Support, 2018) and Google NEST (Nest Labs, 2018a) enable automation through trigger-action programs known as routines, which help users induce action events in their smart home when a specific trigger condition is satisfied; e.g., when the user gets home (i.e., trigger) turn the security camera OFF (i.e., action). Routines are the building blocks of home automation.

Prior research has often studied routines, and more specifically, IoT apps published in marketplaces such as the Samsung SmartThings Official Repository (Samsung, 2018), to explore the security, safety, and privacy properties of home automation  (Tian et al., 2017; Jia et al., 2017; Celik et al., 2018b; Wang et al., 2018; Nguyen et al., 2018, 2018; Ding and Hu, 2018; Celik et al., 2018a; Celik et al., 2019; Kafle et al., 2019). For instance, researchers have analyzed routines to detect the security and safety consequences of combinations of routines (e.g., Soteria (Celik et al., 2018b), IoTGuard (Celik et al., 2019), and IoTMon (Ding and Hu, 2018)), enable contextual integrity (e.g., ContexIoT (Jia et al., 2017)), ensure informed user-consent (e.g., SmartAuth (Tian et al., 2017)), provide general provenance information (e.g., ProvThings (Wang et al., 2018)), and track privacy leaks (e.g., Saint (Celik et al., 2018a)).

While prior research gives us a useful estimate of problems that could occur in smart homes, the findings would only be actionable iff users utilize a specific combination of these apps in a specific manner (e.g., triggered in a particular order). However, without any complementary insight into what routines people actually deploy, or how they execute them, it is difficult to put the findings of prior work into perspective, or to prioritize them. Generally speaking, without observing realistic home automation usage, it is difficult to practically instantiate and evaluate research in this domain. For instance, a researcher creating policies for Soteria (Celik et al., 2018b) or IoTGuard (Celik et al., 2019) needs to come up with use/misuse scenarios for smart home devices, which requires significant manual effort, is limited by the perspective of the researcher, and may not reflect the use/misuse scenarios that occur in user homes. Similarly, without access to actual events that occur in user homes, systems like ContextIoT (Jia et al., 2017) and IoTSAN (Nguyen et al., 2018) would continue to be evaluated with random events as input, which may not reflect the practical performance of the system.

From these instances, we observe a common gap that limits the practicality of current research: the lack of natural home automation scenarios, i.e., sequences of events that would be reasonably likely to occur in end-user homes. For example, consider the following sequence of three events:

temperature drops below 70F $\rightarrow$ electric blanket turns ON

$\rightarrow$ smoke detector detects smoke and sounds the alarm.

This scenario is fairly common, as electric blankets have often led to fires, especially when left ON or unattended for a long time (Nathalie Sturgeon, 2019; Mia Sims, 2019; Heather Pickstock, 2019). The design and evaluation of security and safety systems for the smart home would stand to significantly benefit if such scenarios were widely available. This paper is the first step in our vision of developing a natural perspective of home automation that can be used to predict natural scenarios, to be used for the design and evaluation of security systems. We explore how this natural perspective can be obtained by learning regularities from user-driven routines in the context of home automation.

User-driven routines are routines that end-users configure through interactive user interfaces (UIs) provided by platform vendors (e.g., the SmartThings official app (SmartThings Support, 2018)) and third-party smart home managers (e.g., Yeti (Yeti, 2018) and Yonomi (Yonomi, 2018)). Such routines are a realization of the “end-user programming” paradigm in smart homes, as users can configure devices and assign triggers and actions without writing a single line of code. Users are empowered to craft their own routines to fit their workflows, without depending upon developer-defined IoT apps for the desired functionality, i.e., user-driven routines directly reflect the requirements of end-users. The following example clearly illustrates our motivation behind focusing on user-driven routines:

IF the doorbell rings THEN turn the security camera ON

The above routine is a straightforward use-case one could imagine with a smart doorbell and a security camera, i.e., it ensures that the camera stays OFF for most of the time the user is home (for privacy), but turns ON when significant events happen, such as when someone is at the door. Indeed, users we collected routines from as a part of our study specified this particular routine (Sec. 4.1). Yet, this routine was not found in any of the 187 IoT apps in the public SmartThings repository; in fact, out of the 273 routines (233 unique) created by our 40 users, more than 42.49% were not represented by any IoT app. This apparent mismatch between developer-provided functionality and actual user needs is a key motivator behind our focus on user-driven routines for modeling home automation.

We propose a novel approach that uses statistical language modeling (Manning and Schütze, 1999) to identify the regularities in user-driven home automation, and leverages them to generate scenarios. Our approach builds upon a key result from the domain of Natural Language Processing (NLP), which states that while a natural language such as English may be extremely expressive in theory, in practice, the actual range of “utterances”, i.e., the use of the language by people, is “natural”, i.e., generally exhibits certain patterns and is, thus, predictable. This result was successfully leveraged and extended by Hindle et al., who demonstrated that source code, just like natural language, is the culmination of human effort, and as a result, contains repetitive patterns making it predictable (Hindle et al., 2012). We hypothesize that just like natural language and software corpora, home automation usage is also natural, and can be usefully modeled using existing language modeling techniques, to identify regularities that would help us generate reasonably common home automation scenarios.

Specifically, we define the notion of a home automation sequence, which is the full, ordered, set of routines that the end-user has scheduled to execute in their smart home (i.e., analogous to functions called within a program). Using this definition, we frame the following core hypothesis to be tested in this paper:

Home automation sequences created by humans are implicitly natural, i.e., while they are subject to certain contextual constraints, these sequences exhibit logical patterns, making them predictable. Hence, statistical language modeling can be leveraged to analyze corpora of home automation sequences and predict useful scenarios to facilitate the design and evaluation of security systems.

We present a framework that enables a natural perspective for Home automation security EvaLuatION (H$\epsilon$lion). We initialize H$\epsilon$lion with routines collected from end-users. Moreover, we observe that the order in which two routines execute may have different, even contradictory, security implications. Hence, for a precise characterization, H$\epsilon$lion obtains execution indicators, i.e., clues from the end user about the potential execution of individual routines, and performs an informed scheduling of the routines in the user’s home, which results in an ordered home automation sequence composed of home automation events as they are scheduled to execute in the user’s home. H$\epsilon$lion then leverages the n-gram language model to learn patterns from multiple home automation sequences, and predict natural scenarios, i.e., sequences of future events that would occur, given the past history of events in a user’s home. For example, the “electric blanket” scenario presented earlier in this section was generated by H$\epsilon$lion. This paper makes the following contributions:

• •

H$\epsilon$lion: We present, H$\epsilon$lion, a novel framework designed to model user-driven home automation sequences, using statistical language modeling, to generate natural home automation scenarios.

• •

Naturalness of home automation: We empirically test the naturalness hypothesis over a home automation corpus (called HOME) consisting of 30,518 events, split among event sequences from 40 users, created using 273 routines. Our evaluation demonstrates that home automation is indeed natural and predictable, even more so than natural language and software corpora.

• •

Validity of predicted scenarios: We study the validity of our scenarios with 16 additional external evaluators. H$\epsilon$lion’s scenarios are generally seen as reasonable/natural by evaluators.

• •

Usefulness of scenarios: We demonstrate the usefulness of the scenarios by using H$\epsilon$lion to generate security and safety policies for home automation. Our evaluation demonstrates that H$\epsilon$lion’s approach significantly automates the use/misuse case analysis workflow by eliminating the need to imagine scenarios. Our approach enabled us to semi-automatically discover 27 unsafe scenarios in user-driven home automation and specify 17 security policies to address them.

Our analysis of the results and feedback from users leads to key findings (\mathcal{F}_{1}$$\rightarrow$$\mathcal{F}_{14}) that demonstrate the strengths of H$\epsilon$lion and surprising aspects of home automation, as well as additional design challenges and future opportunities in this exciting domain.

The rest of the paper is organized as follows: Section 2 motivates the need for natural scenarios, and provides key intuition into language modeling. Section 3 describes H$\epsilon$lion. Section 4 details our data collection approach and initial insights. Section 5 sketches out our evaluation. Sections 6, 7 and 8 demonstrate the naturalness of home automation, and the validity and usefulness of the scenarios generated by H$\epsilon$lion, respectively. Section 9 summarizes the related work, while Section 10 concludes with lessons learned.

2. Motivation and Background

Automatically generating natural home automation scenarios would help a variety of stakeholders in analyzing home automation to fulfill their own security/safety goals. For instance, the following questions from four stakeholders could be addressed with scenarios:

• •

Security Researcher: What is the performance of my security system or policy, under realistic smart home usage?

• •

Platform Vendor: Would the behavior of partner devices be compatible with my design/security policies in end-user homes?

• •

Device/App Developer: Will my security-sensitive device/app pass its unit tests in realistic user-driven automation scenarios?

• •

End-user: Can my smart home setup be unsafe in the future, based on the events that have already occurred?

We focus our motivation on one of the most important challenges in the design and evaluation of current and future systems: policy specification. The next section illustrates how the availability of natural home automation scenarios would enhance the process of specifying home security/safety policies.

2.1. Problem: Effective Policy Specification

Prior research has built systems to discover or defend against a diverse set of security, safety, and privacy problems arising due to the misconfiguration or misuse of IoT apps (Fernandes et al., 2016; Celik et al., 2018a; Celik et al., 2018b; Nguyen et al., 2018; Ding and Hu, 2018; Kafle et al., 2019). However, a common aspect of prior systems is their reliance on predefined security or safety policies for analysis or enforcement. Such policies are often very intuitive, and generally created by security experts based on their understanding of the smart home. For example, Soteria (Celik et al., 2018b) has a policy which states that “the refrigerator and security system must always be on”, which is reasonable, considering the safety and security consequences, respectively, of the refrigerator or security system being OFF. Moreover, policies created in existing literature are often carried over to future systems, e.g., Soteria’s policies have been used and extended by recent systems (Nguyen et al., 2018; Celik et al., 2019). That is, the effective specification of policies is significant for the design and deployment of current as well as future systems. However, there is a gap in how policies are currently specified, as we illustrate with the following two-part motivating example:

Motivating Example Part 1: Manual policy specification: Consider Alice, a security researcher who is building a system to analyze the effect of routines on user safety and security. Alice relies on use/misuse-case requirements engineering (e.g., as in prior work (Celik et al., 2018b, 2019)) to come up with the policies for this system, a process that can be accomplished in three well-defined steps. First, Alice comes up with a list of assets she cares about, i.e., security-sensitive devices such as the door lock or camera, or home states that may have implications on security (e.g., whether the user is home/away, if there is a fire). Second, Alice uses her domain knowledge to come up with a set of home automation use and misuse cases, involving devices as well as environmental factors in the smart home. This step is the hardest, as the assessment of what behavior constitutes use and misuse can often be contextual, and the possible contexts are subjective and rely on Alice’s imagination. For instance, the camera turning OFF can be perfectly normal if the user is at home (i.e., for privacy), but an example of misuse/anomalous behavior, generally, when the user is away (i.e., when monitoring is needed). Finally, once the use and misuse cases are identified, Alice transforms them to functional requirements (i.e., to ensure the use cases) or constraints (i.e., to prevent the misuse cases). However, coming up with the use and misuse cases manually is by itself a significant challenge, costing Alice a tremendous amount of time and effort.

Figure 1 shows an alternate approach that leverages scenarios, which may make Alice’s task significantly easier.

Motivating Example Part 2: Semi-automatic policy specification with scenarios: Recall that a scenario is a sequence of home automation events. As shown in the figure, we intend to replace the second step in requirements engineering, i.e., instead of requiring Alice to imagine use/misuse cases, we assume the existence of a set of natural scenarios that are reasonably likely to occur in an end-user’s home. Alice uses a simple state model to track the state of different assets as each event in the scenario being analyzed plays out. Alice only inspects the state of the home when an interesting event happens (i.e., a security-sensitive event such as opening/closing the door). Inspecting policies is a simply matter of looking at a few smart home states (i.e., the context in which the present event is executing), and judging whether the combination of states is safe or unsafe, with the unsafe ones resulting in policies. The scenarios complement the existing requirements engineering process by making it semi-automated and eliminating the burden of imagining use/misuse cases. Moreover, if the scenarios are natural, i.e., reasonably likely in the wild, then the resultant policies also become much less subjective than before.

Now that Alice can use scenarios to specify policies, the key question is: how can we generate natural home automation scenarios?

2.2. Intuition: Leveraging the Naturalness in User-driven Home Automation

The objective of this paper is to develop a framework for predicting natural home automation scenarios. In simple terms, we want to build a model that can predict sequences of events that are most likely to happen in the future, based on the events that have already happened (i.e., the history). Statistical language models (LMs) enable exactly this type of prediction.

Our core hypothesis (Sec. 1) is that the home automation event sequences resulting from an ordered scheduling of user-driven routines are natural and exhibit patterns that may aid in prediction. The reason behind such naturalness is intuitive as well as an extension of an argument that has revolutionized the areas of NLP and source code analysis: while languages themselves offer tremendous expressibility, actual use of languages by humans is often repetitive enough to be reasonably predictable. For example, in the sentence “You only live ¡missing word¿.”, it is easy to predict that the missing word should be “once”, despite the fact that technically, “barely”, “infinitely” or any other adverb would have been just as syntactically correct. A language model trained on corpora of the actual “utterances” or use of English would be very likely to make the same prediction, simply based on the statistical probability of the word “once” given the preceding phrase.

In a similar vein, home automation events generally follow predictable patterns. Imagine the following sequence of events in a room where a light is controlled by a motion sensor: “motion sensor detects motion, lights are turned ON, motion is not detected for a while, ¡missing event¿”. Intuitively, here the concluding event would most likely be “lights turn OFF”. To leverage this naturalness and make useful predictions, we use statistical language modeling.

2.3. Background: Statistical Language Modeling and n-gram models

A statistical LM, fundamentally, measures the probability of a sentence, given the probabilities of the individual words in the sentence, previously estimated from a training corpus. That is, traditionally, a statistical LM is defined as a probability estimation over units of written/spoken language, which measures the probability of a sentence $s=w_{1}^{m}=w_{1}w_{2}...w_{m}$ based on word probabilities. This ability can also enable prediction, i.e., by predicting the next most probable word that can follow a sequence of words. In the context of modeling smart home routines, we define a “sentence” to represent a sequence of home automation events, wherein the “words” (a.k.a tokens) are atomic smart home events (e.g., ¡LightBulb,switch,ON¿).

Thus, our approach will measure the probability of an event sequence $s=e_{1}^{m}=e_{1}e_{2}...e_{m}$ according to its constituent events $e$, relying on the chain rule of probability, as follows:

[TABLE]

The n-gram language model: In practice, however, there are often too many unique sentences or sequences to properly estimate the probability of tokens given long histories, even with large training corpora. Thus, we make use of the n-gram language model, which assumes the Markov property, i.e., instead of computing the conditional probability given an entire event or language history, we can approximate it by considering only a few tokens from the past. The intuition behind n-gram language models applied to natural language is that shorter sequences of words are more likely to co-occur in training corpora, thus providing the model with more examples to condition token probabilities, enhancing its predictive power. While n-gram models are valued for their practicality in NLP and software analysis contexts, they are arguably an even more intuitive fit for analyzing home automation event sequences. This is due to the organic semantic relationships smart-home events exhibit, i.e., the localized causal relationship between triggers and actions (e.g., a trigger preceding a corresponding action or set of actions), which are more relevant than presumably weaker correlations with events from the distant past. Using the n-gram model, we estimate the probability of the event sequence $s=e_{1}^{m}=e_{1}e_{2}...e_{m}$ as follows:

[TABLE]

Evaluating the naturalness of a corpus: The effectiveness of n-gram modeling in the context of smart home events holds only if our intuition regarding the naturalness home automation event sequences drawn from user-directed routines is correct. Thus, we must answer the question: Are such event sequences natural? Fortunately the naturalness of token sequences can be measured according to a trained model’s perplexity (or its log-transformed version, cross-entropy) on unseen data. These are standard metrics used to test the viability of statistical language modeling for modeling any corpora. A trained model will be “perplexed” upon observing a new sequence if it finds the sequence surprising, i.e., unlike any sequence observed in the corpora. Thus, if a domain is natural, then the perplexity of a model built on corpora from the domain (e.g., home automation event sequences from a population of users) when applied to new sequences from the same domain should be measurably low. That is, the model should be able to identify regularities in the event sequences, and hence, predict new sequences with confidence. The cross-entropy $H$ of an n-gram model $M$ can be computed as follows:

[TABLE]

where $H_{M}$ is the average negative log probability that the model $M$ assigns to each event $e_{n}$ in a test sequence. Perplexity is $2^{H_{M}}$.

3. The H$\epsilon$lion Framework

Figure 2 shows H$\epsilon$lion, a data-driven framework that models the regularities of user-driven home automation, generates natural home automation scenarios, and provides stakeholders with tools to use the scenarios and obtain actionable outcomes. As shown in the figure, the process begins by collecting user-driven routines, as well as the corresponding execution indicators, i.e., clues about when or how frequently the routines may be scheduled to execute, from end-users. H$\epsilon$lion transforms the routines and the corresponding execution indicators into home automation event sequences, using a process called informed scheduling. The resulting event sequences serve as a training data set that is represented using n-gram language modeling. H$\epsilon$lion’s language model captures the patterns among the home automation sequences, and can confidently generate new natural events that follow a home’s previous history. A sequence of such predicted events forms a scenario.

H$\epsilon$lion’s underlying language model and sequence generation capabilities make possible a number of practical applications for improving smart home security and safety. We envision a set of tools – developed to leverage H$\epsilon$lion’s scenarios – that enable these applications for stakeholders. In the scope of this paper, we present and evaluate H$\epsilon$lion’s application to policy generation via a tool called the snapshot module. This module allows security researchers to specify policies using H$\epsilon$lion’s scenarios (Sec. 2), by capturing the various device states of a smart home (i.e., a “snapshot” of the home), every time a successive event in a predicted scenario is assumed to execute. We evaluate this application of H$\epsilon$lion in depth in Sec. 8.1. In addition to our main focus of policy generation, we also outline the execution engine we have prototyped, and discuss its potential use by platform vendors and device manufacturers to execute the scenarios on real devices for testing the compliance of partner devices with the their own security/safety design policies (Sec. 8.2). Finally, while we do not explore this aspect, H$\epsilon$lion could be integrated into existing policy checkers (e.g., prior work such as Soteria (Celik et al., 2018b) or IotSAN (Nguyen et al., 2018)) in order to enable end-users to identify potential security/safety problems in their homes.

Next, we describe the key choices that we made while designing H$\epsilon$lion, which is followed by our evaluation of the naturalness, validity, and usefulness of the scenarios it generates (Sec. 5$\rightarrow$8).

3.1. Collecting User-driven Routines

Recall that user-driven routines are routines created by end-users, typically with no programming experience, through interactive UIs provided by the platform (e.g., the SmartThings app (Smartthings Developers, 2018)) or third-parties (e.g., Yonomi (Yonomi, 2018)). As these routines are created by end-users, they reflect user requirements directly, relative to the marketplace IoT apps designed from a developer’s perspective. H$\epsilon$lion’s language modeling and sequence generation is rooted in user-driven routines. Thus, an important step in instantiating these models is the collection and representation of the events that constitute user-driven routines into semantically meaningful tokens suitable for modeling. We describe this procedure in the remainder of this subsection.

1. Collecting routines from users: To collect routines from users, we use a survey methodology that is conceptually similar to prior work (Ur et al., 2014). We thoroughly describe this methodology in Sec. 4.1, with additional survey artifacts provided in Appendix A. At the end of this survey process, the raw data collected from users consists of two components: (i) routines specified in a structured natural language format, and (ii) clues for when these routines will typically execute called execution indicators, which are used later in H$\epsilon$lion’s informed scheduling process. Consider this (raw) example routine taken directly from our dataset:

IF the motion is detected THEN turn the light bulb on

In order for smart home events to be suitably modeled by H$\epsilon$lion’s n-gram language models, these structured natural language routines must be converted into semantically equivalent tokens. In a traditional statistical language model applied to natural language, the vocabulary of tokens is typically defined as the unique set of words that exist within a corpus. To derive a similar set of semantically unique events for a smart home, natural language descriptions of the same event that differ slightly (e.g., motion is captured vs. motion is detected) must be resolved into the same token, following the token structure we define below. H$\epsilon$lion automates certain aspects of this procedure to make for a semi-automated conversion (see Sec. 4.1).

2. Representing smart home events as tokens: In the context of this paper, the tokens are home automation events parsed from structured natural language descriptions of user-driven routines. A home automation event can denote a change in the state of a device (e.g., lock the door) or the home (e.g., the user is away). To model the varying attributes of home automation events, we express our tokens as ordered information lists called tuples. The design of the fields of our tokens dictates their overall uniqueness and granularity. Therefore, to effectively represent home automation events, the design of the tokens must strike a balance between encoding enough salient information to be descriptive, while still representing semantically similar events in equivalent tokens to capture meaningful patterns in the data. We define H$\epsilon$lion’s home automation event token as:

$e_{i}:=<device_{i},attribute_{i},action_{i}>$

where $device_{i}$ represents the device (e.g., door lock, camera), the $attribute_{i}$ corresponds to one of a predefined set of device attributes (e.g., the lock attribute for the door lock, which can take the values Locked/Unlocked), and $action_{i}$ represents the change of state that has led to the event. For example, an event token for the trigger event “If the door lock is locked” is represented by the following tuple: $<door\_lock,lock,$Locked$>$. Note that to represent an event that causes a change to the overall state of the home (e.g., “If the user is home”), we do not use the first (i.e., device) field, instead only using the attribute (i.e., “home”) and the specific change (i.e., Home or Away), to generate a token as follows: $<\phi,locationMode,$Home$>$. Using this design, the example routine discussed above (i.e., the motion sensor/light bulb routine) would be tokenized as follows:

$<motion\_sensor,motion,$detected$>$, $<light\_bulb,switch,$ON$>$

Of the several considerations that went into the design of this token, the most important was the decision to exclude a classification of an event as a trigger or an action. This decision considers that we had to model home automation “event sequences” rather than a set of routines. That is, many events can be both triggers and actions, depending on how/where they are used in a routine; e.g., the trigger condition “if the door is Locked”, and the event resulting from the action “Lock the door”, deal with the same device, attribute, and device-action, but may be either a trigger or an action depending on where they are used in the routine. This decision also prevented unnecessary sparseness in our dataset, i.e., as representing the same home automation event (i.e., the door being locked) using a token format that included a trigger/action specification would generate two separate tokens.

3.2. Generating Home Automation Event Sequences with Informed Scheduling

In order for H$\epsilon$lion to model meaningful sequences of smart home events, the individual routines collected from users must be arranged into temporally meaningful sequences. H$\epsilon$lion transforms the tokenized routines specified by a particular user into a home automation event sequence, i.e., an approximate representation, in terms of a sequence of event tokens, of how the routines would execute in the user’s home, for a given period of time. The “order” in which routines may execute in a home in any given day becomes important for the purpose of constructing this approximation. This importance of order can be readily observed in natural language, i.e., while single words carry with them isolated meaning, a combination of words in a sentence with specific, intentional ordering form a more expressive collective meaning. The same can be said about home automation, i.e., where home automation events are like words in a sentence, and the order of such events is bound to affect the “meaning” (i.e., implications) of the home automation sequence. To illustrate this point, consider a simple sequence of two events:

motion detected $\rightarrow$ light turned ON

Intuitively, we can interpret this sequence as meaning that the light turns ON because motion is detected. On the contrary, if the order was reversed, the sequence would not have a readily apparent logical meaning. This simple example demonstrates how generating event sequences and when scheduling routines in the right (or best-effort) order is important. The question is: How can we obtain this order?

1. Introduction to Execution Indicators: We propose a novel abstraction for users to stipulate the approximate order in which routines may execute, i.e., routine-specific execution indicators. That is, we consider the possibility that end-users have some intuition regarding when certain routines execute, based on when certain device or environmental events may generally occur. For instance, blinds are usually opened in the morning, and closed at night. As a result, a user may order a routine triggered by the opening of the blinds before another triggered by their closing. Similarly, users may be able to describe when they perform certain personal tasks which trigger home automation, i.e., when they come home, go to work, bed, cook, or do laundry. Execution indicators allow us to capture these and other such factors, which we then leverage to schedule routines to create home automation sequences. This is why we define the approach as informed scheduling, as the scheduling mechanism is informed by the user’s understanding of their own home use.

2. Specifying Execution Indicators and Scheduling Routines:

Execution indicators constitute the time and frequency of the potential execution of a routine. As users may not be able to specify precise values, we collect such indicators by allowing users to pick broad ranges of values organized into three types: (1) the time-range indicator (e.g., early morning, noon, and night), (2) the day-range indicator (e.g., mostly on weekdays, and mostly on weekends), and (3) the frequency indicator (e.g., many times a day, few times a day, few times a month). As mentioned earlier execution indicators are collected from users for each routine during the data collection survey (see Sec. 4.1). We then use these execution indicators to generate a month-long time-series for each user, where each routine may occupy one or more one-hour time-slots (i.e., depending on frequency), using the algorithm for informed scheduling, as follows:

We initialize a month-long time-series, with hourly slots that can hold routines. We first place the routines triggered at specific times (e.g., at 8AM, open the blinds) as defined. For each remaining (i.e., un-placed) routine, we identify the potential slots for placement, based on its time-range indicator. The frequency indicator of the routine determines how many instances of the routine to uniformly distribute among those slots. This distribution is also adjusted, based on the day-range indicator, i.e., skewed in favor of weekdays or weekends. For the few routines without execution indicators (i.e., when users are unsure), we randomly distribute them throughout the month in the remaining slots. Finally, once all the routines have been scheduled in the time series, we extract the ordered set of routines from the time series as the execution sequence. In H$\epsilon$lion, this process is automated by parsing execution indicators for each routine collected in the survey and then programmatically performing the scheduling and sequence extraction.

We later empirically demonstrate that users can confidently supply execution indicators for most routines, only being unsure for generally unpredictable events such as fires/CO leaks (Sec. 4). Moreover, with these approximations of how routines execute, H$\epsilon$lion can create valid (Sec. 7) and useful (Sec. 8) scenarios. Accurately scheduling all possible routines is a broader research challenge that is beyond the scope of this paper, as we discuss in Section 10.

3.3. Modeling Event Sequences

H$\epsilon$lion uses the n-gram model to learn the regularities in user-driven home automation sequences, i.e., it estimates the probability distribution of n-grams in a corpus of the home automation sequences created previously. For estimating probabilities, H$\epsilon$lion follows the approach described previously in Section 2.3.

Why do we need $n\geq 3$?: Recall that when estimating the probability of a sequence of length $n$, the n-gram model computes the probability of the $n^{th}$ token appearing after the $n-1$ previous tokens (i.e., the history). The intuition behind looking back at the $n-1$ events is that they provide the context as to why the $n^{th}$ event is being scheduled. Given this intuition, one thing is clear: when choosing $n$ for modeling home automation sequences, we can rule out values of $n<3$. That is, $n=1$ will only estimate the probability of individual events in the corpus, completely ignoring the context. Choosing $n=2$ is only slightly better, as it may mostly capture simple relationships that are already observable from data, i.e., trigger-action routines we collect from users. Only with larger values of $n$, i.e., $n\geq 3$, the model can learn non-obvious regularities in home automation corpora. To illustrate this point, consider the following example sequence whose probability is being estimated using a 4-gram model, i.e., $n=4$:111We use natural language instead of tokens when describing event sequences.

user comes home $\rightarrow$ lights switch ON $\rightarrow$ it is evening $\rightarrow$ door locks.

Here, the factors such as the user being home, the lights being ON and the time of the day being the evening provide the context for the occurrence of the next event, i.e., the locking of the door. As a result, examining the last $three$ events certainly helps. However, there is a caveat: considering too much of the event history (i.e., a very large $n$) may actually hurt the predictive power of the model. That is, an event that occurred earlier during the day (e.g., the user going to work) would likely not share any semantic relationship to the given sequence, and hence, would not really encapsulate any regularities. As a result, the choice of $n$ directly impacts the ability of the model to capture the existing relationships between events in the corpus, especially if they are related by the virtue of belonging to the same, high-level user-activity (e.g., end-of-day events).

The need for smoothing: Selecting $n\geq 3$ may seem to intuitively lead to a better model, however, for higher orders of $n$ there will inherently be fewer sequences for the model to learn from. This is because longer sequences tend to be unique, i.e., the sequence:

the user leaves the home $\rightarrow$ the door locks

may occur often in a set of sequences, whereas the sequence:

user leaves the home $\rightarrow$ door locks $\rightarrow$ motion is detected

is likely to be less common. This leads to a data sparsity problem, wherein it is likely that a history queried during prediction may have not been observed in a training corpus. As a result, a naive model will be unable to predict the next event, i.e., if this entire history is not present in the training corpus, the model will not be able to make a good prediction, even if it may have observed subsequences of this history (e.g., user leaving & door locking). To allow the LM to assign probabilities (i.e., useful predictions) to previously un-observed sequences with sufficient statistical rigor, we rely on smoothing (Chen and Goodman, 1999). Smoothing is a well-known technique in NLP where the model assigns some probability distribution to rare or unobserved sequences. We consider two smoothing methods to improve the prediction quality of the model with higher-order n-grams, i.e., (1) backoff and (2) interpolation. At a high level, backoff smoothing techniques simply revert to predictions based on lower order n-grams when an observed history of higher order n-grams are rare or haven’t been observed. Conversely, interpolation always considers and combines token probabilities for lower-order n-grams when making predictions. In our instantiation of H$\epsilon$lion, we elected to use interpolated n-grams due to their demonstrated ability to perform well with lower-order (i.e., 3-4 gram) models (Chen and Goodman, 1999).

3.4. Generating Different “Flavors” of Scenarios for Security/Safety Applications

H$\epsilon$lion generates scenarios by treating the model as a sequence generator that can produce an arbitrarily long series of smart home events, given a history. That is, given a history, the n-gram model looks at the previous $n-1$ events, and predicts the next most probable event. For the next prediction, the newly predicted event now becomes a part of the history (i.e., the latest event in the history). We can continue these predictions to get arbitrarily long scenarios. These predictions can be used to generate scenarios that are natural, i.e., reasonably likely to happen in some user’s home, and very likely with respect to the training data. However, in applying H$\epsilon$lion in practice (e.g., for policy specification) it may be desirable to generate both highly natural and unnatural event scenarios.

Consider the policy specification example from Sec. 2, where Alice, needs scenarios that can replace her need to come up with use and misuse cases. That is, Alice not only needs likely scenarios, but she also needs highly unlikely scenarios, which may not be normally observed or expected, and hence, may actually demonstrate stress tests, or rare but unsafe situations. Prior work demonstrated that LMs can be configured to generate different flavors of event sequences (Linares-Vasquez et al., 2015), aside from the standard natural event sequences they predict. In a similar vein, H$\epsilon$lion can be configured to generate two flavors of scenarios, motivated by our policy specification use case:

The up flavor, for non-adversarial use: This flavor is the default, i.e., where our model generates highly probable event sequences, given a history using the natural probability distribution over tokens in the training corpus. The up flavor demonstrates the “normal” patterns in user-driven home automation, which may be used for many evaluation tasks that require producing normal home automation scenarios. For instance, the up scenarios may be analyzed to diagnose configuration-related safety issues in user-driven home automation.

The down flavor, for deliberate misuse: The down flavor corresponds to an unnatural distribution over tokens, i.e., down scenarios will exhibit patterns that are highly improbable given the model’s probability estimation. H$\epsilon$lion’s language model generates down scenarios by sorting the model’s most probable token predictions given some history, and then reversing this order, such that the most improbable token is given by the model as the prediction. Thus, the down flavor can be thought of as a stress test, where highly unlikely events are purposefully predicted. The down scenarios may be interpreted as a system under constant attack, or where all devices are simultaneously malfunctioning, or exhibiting “abnormal” behavior.

4. Data Collection and Initial Findings

In this section, we describe our data collection methodology, our approach for constructing the HOME corpus consisting of home automation sequences for use with H$\epsilon$lion, and most importantly, important initial findings that can be directly gleaned from the data.

Data Availability and IRB Approval: We plan to release anonymized datasets (i.e., including the HOME corpus) upon publication. Further, all the user studies and surveys described in this paper were approved by our institutional IRB.

4.1. Methodology for Collecting Data from Users

We use a survey methodology for collecting data from end-users. We surveyed 40 end-users who were generally from the Computer Science (CS) academic population: 37 participants were current graduate and undergraduate students, and 3 had PhDs. A majority owned at least one smart home device (24 or 60%), while a significant minority had experience creating routines (17 or 42.5%). The HOME corpus was constructed using the data from these users.

To make the task of specifying routines and indicators easier, we split the survey into a series of logical steps that we describe in this section. We have made the survey available in the Appendix A.

1. Selecting devices: First, participants selected devices that they could envision (or already have) in their smart home. To enable this step, we provided the participants with a broad device list consisting of 70 unique types of devices available in the market. We constructed this list using resources such as websites and mobile apps of all the device partners of the popular Samsung SmartThings (Smartthings Developers, 2018) and Google NEST (Nest Labs, 2018b), popular technology websites, and technology forums. Fig. 4 in Appendix A shows our device selection screen.

2. Creating routines: After selecting devices, the participants were given a short tutorial on routines, and asked to create one or more routines using the devices that they had previously selected, along with general smart home variables such as the user being home/away, temperature, and time. We asked the participants to provide triggers and actions in a plain English text to allow them to express any functionality desired. We provided interactive form with two text boxes (i.e., for triggers and actions) as shown in Fig. 6 of Appendix A.

We provided participants with the functional information about devices in the survey, to help them focus on the task of creating routines. As shown in Fig. 5, participants could view the functional attributes (e.g., the “lock” attribute for the door lock device) that were applicable to every device they had previously selected, as well as the general smart home variables. To enable this approach, we created a device-attribute map by systematically assigning one or more of the 110 attributes that we obtained from existing platforms (e.g., NEST (Nest Labs, 2018b) and SmartThings (Smartthings Developers, 2018)) to each of our 70 devices.

3. Specifying Execution Indicators: After creating routines, participants specified the time-range, day-range and frequency indicators for the routines they created, shown in Fig. 7, 8 and 9 respectively. Participants could select from predetermined ranges, as well as indicate “anytime” for routines that could occur at any time (i.e., with respect to the time-range and day-range indicators), or “not sure” if they were unable to specify. In addition to collecting routines and execution indicators, we also collected information that may assist in understanding user-driven home automation (see Appendix A).

4.2. Constructing the HOME Corpus

The routines created by the participants in plain English were transformed into an intermediate trigger-action format, and then tokens, using the syntax described in Sec. 3.1. We also considered two additional situations when tokenizing: (1) if the trigger/action consisted of a conjunction of events, we combined the events into a single token (in the alphabetical order by device), as those events would be expected to execute simultaneously, and (2) for attributes with continuous values (e.g., temperature), we abstracted the user-provided values into ranges (e.g., low, medium, and high temperature), to create semantically unique tokens. Two authors independently verified the correctness of the tokens. Finally, we constructed a month-long home automation event sequence for each participant using informed scheduling (Sec. 3.2), creating the HOME corpus.

4.3. Initial Findings

The HOME corpus consists of 30,518 home automation events, from 40 month-long sequences (i.e., for 40 users), generated from 273 routines (233 unique) and their execution indicators specified by users. We use the HOME corpus for our evaluation in Sec. 5$\rightarrow$ 8. Next, we describe observations and findings from our data analysis.

Finding 1 ($\mathcal{F}_{{1}}$): Routines are important to users. Moreover, users leverage most available devices for creating routines. When asked how important routines were to them, 4 users or 10% indicated that routines were “very important”, 20 users or 50% indicated “important”, while 16 or 40% indicated “somewhat important”. No user indicated that routines were unimportant.

Further, our participants used 61 out of the 70 devices provided (or 87.14%) in at least one routine. Devices related to lighting and temperature control were the most popular for automation (i.e., selected by 23 and 21 users respectively), closely followed by security devices such as cameras. This finding indicates a strong user preference for creating routines and integrating device functionality.

Finding 2 ($\mathcal{F}_{{2}}$): SmartApps do not represent a significant number of user-driven routines. Out of the 233 unique routines created by our 40 end-users, only 134 or 57.51% could be represented by SmartApps from the SmartThings market (Samsung, 2018), i.e., 42.49% were not. Moreover, only 40 out of the 187 SmartApps or 21.39% actually accounted for the represented routines, i.e., our users would potentially not use the remaining 147 or 78.6% SmartApps.

Finding 3 ($\mathcal{F}_{{3}}$): Users indicate a strong preference for controlling/creating their own routines. Most users (i.e., 32 or 80%) indicated that their source of ideas for creating routines were personal requirements. Moreover, when asked about their preference for vendor-controlled versus user-controlled home automation, most users (20 or 50%) said they would prefer a combination of both, a significant minority (i.e., 17 or 42.5%) said they would prefer a purely user-controlled home automation setup where users define routines, whereas a negligible number said they would prefer a vendor-controlled setup (3 or 7.5%).

Finding 4 ($\mathcal{F}_{{4}}$): Users may perceive any device as security sensitive, depending on the context. We asked participants to select devices (out of 70) they considered to lead to harm if compromised or malfunctioning (i.e., are security/safety-sensitive). As expected, the devices directly aligned with security/safety were primarily selected, such as the security alarm (36 participants), door lock (35), camera (35) or the garage door opener (31). Even more surprising was that every single device was marked as security/safety-sensitive by at least 3 participants; i.e., participants also considered tangential scenarios where their well-being may depend on the device, even if security/safety is not its primary feature.

Finding 5 ($\mathcal{F}_{{5}}$): Users can confidently specify certain execution indicators, aside from certain unpredictable triggers. Table 1 summarizes the options chosen by our participants, i.e., selected one of the specific ranges offered, or anytime, or “not sure”, for each of the three execution indicators (i.e., time-range, frequency, day-range). Our data shows that the participants could specify execution indicators confidently for most of their routines, i.e., they were “Not sure” in very few cases (i.e., at most 10.26%, for the day-range indicator). Moreover, users are generally able to select specific time-range and frequency values for a majority of their routines, i.e., for time-range (i.e., 56.78%) and frequency (i.e., 93.77%). This clearly demonstrates that users are able to confidently supply execution indicators for most of their routines. On further analyzing the “Not sure” cases, we discovered that most are caused by triggers that are unpredictable by nature, e.g., CO leaks or drastic temperature changes, which explains why users could not specify them.

The analysis of the survey data exposes the evident need to analyze user-driven routines (\mathcal{F}_{1}$$\rightarrow$$\mathcal{F}_{3}), and additional challenges, such as unpredictable execution indicators ($\mathcal{F}_{5}$). Sections 5$\rightarrow$8 will explore this data further in terms of the naturalness of the home corpus, as well as the validity, and usefulness of H$\epsilon$lion’s scenarios.

5. Research Questions (RQs)

The three major RQs address the core contributions of this paper:

• •

RQ1 : How natural is home automation corpora?

• •

RQ2 : Do the scenarios generated seem valid to the end-user?

• •

RQ3 : Can H$\epsilon$lion’s natural scenarios be applied in useful ways to improve the security and safety of home automation?

To answer $RQ_{1}$, we test our naturalness hypothesis for our HOME corpus, which is the foundation of H$\epsilon$lion (Sec. 6). $RQ_{2}$ deals with the perceived validity of the scenarios/event sequences H$\epsilon$lion generates. To answer this question, we perform two experiments with external evaluators, i.e., 16 users who were not a part of the HOME corpus (Sec. 7). To answer $RQ_{3}$, we revisit the policy specification problem from the motivating example, and demonstrate how H$\epsilon$lion’s scenarios enable an expert to predict security and safety policies with manageable effort (Sec. 8). We also explore how stakeholders may gain insight into the security/safety problems in platforms/devices under realistic circumstances, by executing the scenarios in an execution engine based on the SmartThings platform.

6. Evaluating the Naturalness of HOME ($RQ_{1}$)

We test our naturalness hypothesis by comparing the cross-entropy of real user-driven home automation sequences with that of a popular natural language and software corpora. Recall that cross-entropy is a measure of how perplexed a model is when it is exposed to a sequence from a corpus of the same domain from which the model was trained (Sec. 2.3). We measure cross-entropy of the HOME corpus, using the MITLM toolkit (Bo-June Hsu, 2018). To properly measure the cross-entropy of our corpus, we perform 10-fold cross-validation. Moreover, since naturalness is relative, we compare the cross-entropy of the HOME corpus for different n-grams with that of the Gutenberg corpus (i.e., English), as well as a software (C# 222The C# corpus shows the best cross entropy out of all the programming corpora (Hindle et al., 2012)) corpus by Hindle et al. (Hindle et al., 2012).333We obtained the raw cross entropy values for the C# and Gutenberg corpora from  (Rahman et al., 2019)

Results: As seen in Figure 3, the cross-entropy for the HOME corpus starts at a high of 6.9 bits for a unigram model, drops to 2.70 bits for the bigram model, and then stays close to 1.7 bits for the rest of the values of $n$ from 3 up to 10. There is an explanation for this trend: As our corpus is generated from trigger-action pairs (i.e., user-driven routines), a unigram entropy is expected to be much higher, as the unique token frequencies may be heavily skewed. However, as the model considers more history (e.g., for the bigram), the entropy drastically reduces. This trend is observed in the Gutenberg and C# corpora as well. We now discuss the key finding from our analysis:

Finding 6 ($\mathcal{F}_{{6}}$): The HOME corpus is natural relative to English language and software corpora, without any syntactic glue. As seen in Figure 3, the HOME corpus has much lower cross-entropy values, and can be said to be more natural, which satisfies our naturalness hypothesis ($RQ_{1}$). Further, there is another interesting aspect of the HOME corpus: the user-driven home automation sequences in the HOME corpus are purely semantic in nature, i.e., have zero syntax involved, and only capture the functionality that the user desires from the automation. On the contrary, C# or any other software corpora sometimes appear more natural than they are because of the common “syntactic glue” (Rahman et al., 2019), which leads to a steep drop in naturalness if the glue is removed (see “C# without Syntax Tokens” in Figure 3). That is, while the naturalness of software corpora will drop when the syntactic glue is removed, the HOME corpus will be unaffected, which indicates it’s amenability to being predicted.

This section demonstrates that our model captures the regularities in the HOME corpus. Thus, the scenarios generated by H$\epsilon$lion will be natural (i.e., likely based on the observed sequences). However, are such scenarios valid according to end-users? The next section addresses this question with two studies with external evaluators.

7. Evaluating the Validity of the Scenarios ($RQ_{2}$)

As the intended use case for H$\epsilon$lion is the generation of scenarios for a variety of security applications, it is equally important to understand how valid (i.e., reasonable) the scenarios generated by H$\epsilon$lion are in the view of end-users ($RQ_{2}$).

We assessed the ability of H$\epsilon$lion to generate valid scenarios with 16 evaluators, i.e., a separate set of users who were not included in the initial 40 users described in Sec. 4.1, but from the same user population. This evaluation consists of two studies. First, we conduct the routine comparison study (Sec. 7.1), i.e., we evaluate whether H$\epsilon$lion can generate routines that are just as valid as the routines collected from users, in the view of the evaluators. This allows us to reason about validity in comparison with a real baseline. We then move on to evaluating the sequences generated by H$\epsilon$lion, i.e., the scenarios, with the sequence generation study (Sec. 7.2). That is, we generate scenarios using histories given by the external evaluators, and test their validity under various model configurations. The survey instrument used in these experiments is illustrated in Appendix B.

7.1. Routine Comparison Study

We envision that many applications of H$\epsilon$lion will rely on its ability to generate reasonable bigrams, i.e., pairs of events which may be analyzed as routines. Using the routines previously created by end-users as our baseline (Sec. 4.1), this study answers the following key question: does H$\epsilon$lion generate routines that are as valid as routines created by real end-users?

Generating Routines: We used the HOME corpus to generate routines. Recall that H$\epsilon$lion is a sequence generator, and will predict a sequence of events, one event at a time, if given a certain history (Sec. 3.4). We predict routines using an approach similar to 10-fold cross validation: i.e., in every round, we split the dataset randomly into 90%/10% sequences, train on the 90%, sample histories from the 10% testing sequences (i.e., pick random subsequences of “odd” length), and use them to generate sequences. Since these histories are of odd lengths, it is likely that the first prediction using any such history will be the completion (i.e., the action) of a routine, the trigger of which was the last event in that history. As a result, we assume the second and third generated events as a fresh routine.

We randomly generated 40 such unique routines, generated through the following configurations of the model (i.e., varying the n-gram and up/down modalities): (i) up/3-gram (10 routines), (ii) up/4-gram (10 routines), (iii) down/3-gram (10 routines), and (iv) down/4-gram (10 routines). We chose the up flavor to answer the validity question, but we also chose the down flavor to understand if really unnatural routines (i.e., down) are also perceived by users as invalid. Additionally, we randomly selected 10 unique routines from 10 different users from the data collected in Sec. 4.1, i.e., (v) survey (10 routines).

Methodology: We conducted this study in-person, wherein a proctor explained the study procedure to the evaluators, and noted down any comments. Evaluators were asked to rate each of the 50 unique routines described previously, in terms of how valid (i.e., reasonable) they seemed, according to a modified Likert Scale (i.e., with options: Strongly Agree, Somewhat Agree, Somewhat Disagree, and Strongly Disagree). The order of routines was randomly shuffled for each evaluator to mitigate inductive bias. Additionally, evaluators were given the opportunity to provide additional feedback after the task.

Results: Table 2 summarizes the ratings for the 10 routines in each configuration by 16 evaluators (i.e., 160 ratings per configuration). The evaluators generally rated the routines generated using the up flavor as well as the routines from the survey as valid/reasonable, whereas the routines generated using the down flavor were mostly rated as invalid. We now describe our findings:

Finding 7 ($\mathcal{F}_{{7}}$): Routines generated using H$\epsilon$lion are as valid as routines created by users. Our evaluators rate over half (i.e., 50.63%) of the up/3-gram routines and 69.38% of the up/4-gram routines as strongly agree. In the latter case, H$\epsilon$lion actually scores higher than the 63.75% strong agreement for the survey routines. Moreover, the total agreement (i.e., strongly plus somewhat agree) is just over 70% for up/3-gram routines, and 82.5% for the up/4-gram routines, the latter of which reasonably valid, relative to the 88.75% agreement for the survey routines.

Finding 8 ($\mathcal{F}_{{8}}$): down routines are generally perceived as invalid, and sometimes perceived as unsafe/insecure. Both down/3-gram and down/4-gram routines are overwhelmingly rated as invalid, with 68.13% strong disagreement in both cases. This implies that the unnatural sequences generated by H$\epsilon$lion are also generally invalid according to users. This finding for routines is likely to extend to longer scenarios as well. More importantly, some users commented that these routines were unsafe; e.g., one user said that “…automations are a hazard. If I’m not home I don’t want to gas stove to turn on.” This finding validates our approach of using highly unnatural sequences for stress testing or modeling adversarial misuse cases.

Finding 9 ($\mathcal{F}_{{9}}$): The notion of validity may vary due to personal preferences, even among users from the same population. Evaluators rated 7.5% of the survey routines as strongly disagree, and another 3.75% as somewhat disagree. This indicates that even within the same population, there is diversity in terms of what users consider to be a reasonable routine. A reason for this variance is personal preference. For example, one evaluator said that they needed additional conditions to be stated, without which the routine would be invalid: “…For the routine if time is Morning, turn the Coffee Maker on, the user should also be at home.” In some cases, evaluators did not agree with a particular device being a part of the “trigger”/“action”, while everything else in the routine seemed reasonable. These preferences also led to many of the “somewhat” ratings.

7.2. Sequence Generation Study

The sequence generation study measures the ability of H$\epsilon$lion to produce valid sequences of lengths larger than 2, based on histories provided by the external evaluators. We also wanted to test if the validity of the generated sequences improves if we collect home automation sequences from the evaluators and include them in the model. That is, we expect that just as NLP-based auto-complete approaches improve in their predictions after learning from the user’s data, H$\epsilon$lion’s scenarios for a user will improve once H$\epsilon$lion knows more about the user’s home automation context. Therefore, prior to the study, we collected user-driven routines and execution indicators from the evaluators and computed home automation sequences for them, using the approach described in Sec. 4.1. Also, we asked the evaluators to provide us with two histories (i.e., sequences of events that would happen in the evaluator’s home).

Methodology: This study was also conducted using an approach similar to the routine comparison study, with a few key differences. First, all four model configurations were of the up flavor, i.e., the general up/3-gram and up/4-gram models trained on the HOME corpus, and specific up/3-gram and up/4-gram models for each evaluator trained on the home automation sequences for that evaluator, in addition to the HOME corpus. Second, each of the four models was used to generate 5 successive events, for the two separate histories provided by each evaluator. The evaluator rated the validity of a generated event based on the history used to generate it, rating 40 events in total. We did not use the down flavor in this study to reduce the cognitive load on the evaluators and prioritize quality responses and rationale by asking no more than 40 questions per evaluator.

Results: Table 3 summarizes the evaluator ratings for the scenarios generated by H$\epsilon$lion (i.e., 160 ratings per configuration). Evaluators mostly agreed with the routines produced by H$\epsilon$lion (i.e., over 62% for the model trained on HOME alone (both 3 and 4-gram), and much higher when including the evaluator’s data. Further, evaluators justified scenarios as reasonable with additional explanation/situations in most cases and were confident about their choices.

Finding 10 ($\mathcal{F}_{{10}}$): H$\epsilon$lion is able to generate reasonable scenarios, despite previously unseen tokens in evaluators’ histories. Tokens outside the model’s vocabulary are known to hurt the predictive capabilities of language models. The histories provided by 8 out of 16 evaluators contained tokens that were simply not present in the HOME corpus. Despite these disadvantages, H$\epsilon$lion delivers a reasonable worst case performance, i.e., achieving an overall validity rating of over 62% in both 3 and 4-gram configurations.

Finding 11 ($\mathcal{F}_{{11}}$): Including the user’s data improves the validity. As shown in Table 3, the models including the evaluator’s event sequences perform much better, with the overall agreement for the 3-gram and 4-gram models rising to 76.88% and 67.5% respectively, from just over 62% previously. Note that whether training with or without the evaluator’s data, the specific histories provided by the evaluators were mostly outside the scope of the model, i.e., only 4 out of the 32 histories provided by our 16 evaluators had subsequences of size 2 or more represented in the training sequences. This finding indicates that use-cases where end-users may want to use H$\epsilon$lion will benefit from this trend, as providing user data will be justified in those cases, and will lead to improved scenarios for end-users.

Finding 12 ($\mathcal{F}_{{12}}$): Context-shifts may lead to lower ratings. H$\epsilon$lion can generate event sequences of arbitrary lengths; however, in reality, many scenarios of varying sizes may occur one after the other in the smart home. We observed that in many cases, users rated the first event of a new contextual scenario very low (i.e., somewhat disagree, or somewhat agree), as they could not reason about it in terms of the history. However, as the new context progressed, the rating improved. Here is a quote that illustrates this problem (the night-related events happened first, followed by the air quality-related events): “The first sequence does not make much sense to me because the air quality detection and the security system/night mode are not clearly related, but these events could technically still happen in sequence. The second sequence makes perfect sense, as you would want the air to be purified if it was detected to be of suboptimal quality.”. This finding indicates that H$\epsilon$lion generates sequences that may actually span multiple, discrete contextual scenarios in the home, which may be useful for a longitudinal evaluation of the home. Moreover, the challenge of capturing these context shifts, and recognizing these scenarios within scenarios, exposes a promising research direction.

8. Evaluating the Usefulness of H$\epsilon$lion ($RQ_{3}$)

We now know that scenarios generated by H$\epsilon$lion are drawn from a natural corpus ($\mathcal{F}_{6}$), and are judged as valid according to end-users ($\mathcal{F}_{7}$, $\mathcal{F}_{10}$, $\mathcal{F}_{11}$). This section demonstrates the usefulness of the scenarios generated by H$\epsilon$lion. We primarily focus on the use of scenarios by security researchers to specify security and safety policies grounded in natural home automation, i.e., the motivating example (Sec. 2). In addition, we also explore the execution of scenarios by building an execution engine, and provide initial insight into how device manufacturers or platform vendors may benefit from the execution of scenarios. Note that the two use cases we discuss are not the only ways to use H$\epsilon$lion; indeed, given H$\epsilon$lion’s generative ability, the possible use cases for various stakeholders are boundless.

We develop two tools to enable these use cases, and expect an ecosystem of additional tools and use cases with community support:

1. Snapshot Module: This module tracks the evolution of states of individual devices and the home, as events are executed in the home (e.g., the “locked” state of the door lock, the home/away mode). That is, given a scenario, this module provides a snapshot for each event, which shows the holistic state of the home on the event’s execution.

2. Execution Engine: To allow the dynamic execution of the scenarios predicted by H$\epsilon$lion, we built an execution engine on top of the SmartThings platform. This engine can execute scenarios on real and virtual devices. Our current setup has more than 15 real devices, and can provision an arbitrary number of configurable virtual devices.

8.1. Helping Researchers Generate Policies

Recall that home automation security policies for prior systems (Celik et al., 2018b, 2019; Wang et al., 2018; Nguyen et al., 2018) are commonly generated using a use/misuse case security-requirements engineering approach (Sec 2). In the example, Alice’s key problems were having to imagine all use/misuse cases, which took significant effort, and not knowing whether her policies are indicative of problems that may happen in the wild. As described in part 2 of the motivating example, using scenarios generated by H$\epsilon$lion may address these challenges.

Enacting the motivating example and predicting policies: We had a security researcher (also an author) with prior experience creating smart home policies using the use/misuse case requirements engineering approach, try out H$\epsilon$lion’s approach and scenarios instead. Our researcher used H$\epsilon$lion to generate scenarios in four configurations: the  up and down scenarios described in Sec. 3.4, as well as two new hybrid configurations, i.e., up-down, which predicts 1-3 down events for every 10 events in an up scenario, and down-up, which does the inverse of up-down. We provided histories from 5 additional users (i.e., outside the HOME corpus) as input for the sequence generation. Each scenario consisted of 13 events, i.e., 3 events from the history and 10 predicted events.

Results: The researcher analyzed each scenario using the snapshot module, and generated 17 policies from 27 unique violations they detected, spending only a few seconds on scenarios that had no interesting (i.e., security/safety sensitive) events, and 1-3 minutes on interesting scenarios, spending about 10 hours. We list all the violations and policies on App. C, and discuss three salient policies:

• •

Preventing an accidental fire (Pol1): In one scenario, we discovered that the gas stove was ON when the user was away. This safety violation could cause a fire, and is addressed with the policy: the gas stove should be OFF when the user is away.

• •

Preventing an explosion (Pol2) We discovered that the gas stove is switched ON after the smoke/CO detector has detected smoke, i.e., when there is already a fire. A gas leak and fire together could lead to a disastrous explosion, regardless of whether the user is home or away (i.e., the violation is unsolvable using Pol1).

• •

Preventing an accidental privacy violation (Pol3) We discovered that the indoor security camera would stay ON, even after the user got home, which could lead to a privacy violation. This is a known problem, and vendors (NEST (Nest Labs, 2019)) offer the flexibility of automatically turning the camera OFF when the user is home

We now discuss our core findings from this experiment:

Finding 13 ($\mathcal{F}_{{13}}$): Scenarios significantly reduce the effort in specifying policies. The effort involved in developing our policies was far lower than what a fully-manual approach of use/misuse case requirements engineering would have entailed. To quote the security researcher from this experiment: “It’s very convenient. The advantage of having the sequences is that they set up a likely or unlikely scenarios without me having to invent it.”

Finding 14 ($\mathcal{F}_{{14}}$): All of H$\epsilon$lion’s configurations, i.e., up, down, up-down and down-up, are useful. Each of our configurations contributed to the policies generated. In fact, for half of the policies, there is only one configuration that leads to it (as shown in Table 4). This indicates that the diversity of scenarios created with H$\epsilon$lion’s prediction configurations is valuable.

8.2. Detecting flaws in platforms and devices

We explore the benefits of executing scenarios to help platform vendors and device manufacturers evaluate their platforms or partner devices in realistic situations. On executing a random set of fewer than 10 scenarios in our SmartThings-based execution engine, we discovered three flaws (two platform and one device):

• •

Dropped actions (Flaw1): On seemingly random occasions, the SmartThings platform was not executing certain events, including security-sensitive events such as locking the door.

• •

Zombie SmartApps (Flaw2): We observed that routines that were previously “deleted” using the SmartThings mobile app (SmartThings, 2019a) were persistently executing in the background, and could only be deleted from the Web IDE (SmartThings, 2019b). This can lead to disastrous consequences if the routine were vulnerable, or a malicious SmartApp.

• •

Unsafe Auto-relock default (Flaw3): We discovered that the Yale lock (SmartThings, 2018) would stay in the unlocked state after the door closed, unless manually locked from the inside. This auto-relock feature is standard in regular keypad locks, but implemented as an inconsistent default in most major lock brands, and worse, not presented to the user during device setup with SmartThings.

While we independently discovered Flaw1 and Flaw2, they were also previously reported on the SmartThings forum by users (SmartThings Community, 2018a, b), which further speaks to the ability of our scenarios to uncover problems that naturally occur in end-user homes.

9. Related Work

In terms of the analysis of user-driven routines, the analysis of IFTTT recipes by Surbatovich et al. (Surbatovich et al., 2017) is similar to this paper. However, there are key differences. First, our goal is to generate natural scenarios of home automation, which differs from the objective of prior work (i.e., security analysis of individual routines). Second, due to our focus on home automation, we primarily study events that take place within the home, unlike prior work, which focuses in IFTTT to study the security/privacy ramifications of connecting external services (e.g., email, Twitter) to the smart home. Third, while prior work examines the safety of individual recipes, H$\epsilon$lion holistically explores the event-relationships in home automation.

Further, the natural perspective provided by H$\epsilon$lion is complementary to the diverse set of security systems and analyses proposed by prior work. Consider ContexIoT (Jia et al., 2017), an access control system that prompts the user for authorization whenever it identifies the use of sensitive operations (e.g., unlocking the door) in new contexts. To measure the frequency of user-prompts (i.e., which affect usability), ContexIoT uses random event sequences generated by fuzz testing of IoT apps. The scenarios predicted by H$\epsilon$lion would provide a more realistic input, leading to a representative evaluation for such systems. Similarly, IoTSAN (Nguyen et al., 2018), a system that uses model checking to analyze IoT setups for safety, also uses random events for evaluation, and may similarly benefit from H$\epsilon$lion. Additionally, H$\epsilon$lion’s down flavor can directly contribute to adversarial benchmarks such as IoTBench (Celik et al., 2018b), for effective evaluation of future work. Further, policy-based enforcement for the smart home (e.g., ProvThings (Wang et al., 2018) and IoTGuard (Celik et al., 2019)) can significantly benefit from H$\epsilon$lion’s semi-automated approach for creating policies (Sec. 8.1).

Finally, recent work has also explored the existence and nature of errors in platforms that utilize trigger-action based programming (Brackenbury et al., 2019; Palekar et al., 2019), as well as techniques for debugging of these errors (Corno et al., 2019).

We see our proposed approach as being largely complementary to this body of work, as H$\epsilon$lion’s event sequence generation could lead to the discovery of new bugs/faults not yet considered by researchers, and more advanced or contextualized debugging techniques.

10. Lessons Learned

User-driven home automation is a complex domain, where home automation event sequences created by users manifest themselves in a highly contextual manner. Inspired by prior work in software engineering (Hindle et al., 2012), this work is the first to attempt to demystify home automation, through an approach that helps in understanding the non-obvious regularities within such user-created sequences, and generates actionable scenarios. Next, we discuss key take aways.

Lesson 1: Home automation is natural, and can be leveraged to generate valid scenarios: Our experiments demonstrate that home automation satisfies the naturalness hypothesis, i.e., sequences created by users are implicitly natural, and exhibit logical patterns that make them predictable ($\mathcal{F}_{6}$). Moreover, we also demonstrate that statistical language modeling techniques can be used to model home automation and generate reasonably valid sequences ($\mathcal{F}_{10}$,$\mathcal{F}_{11}$). More importantly, routines generated by H$\epsilon$lion are comparable with the routines generated by real users in terms of perceived validity ($\mathcal{F}_{7}$). This is an impressive result, given that we used a rather limited HOME corpus for generating these routines. These results serve as a strong foundation for applying advanced statistical modeling techniques for home automation security, and as we (and other researchers) gather more data from real users, we can expect even better performance from H$\epsilon$lion.

Lesson 2: H$\epsilon$lion can be used to generate useful policies and detect real flaws: H$\epsilon$lion generates scenarios that lead to useful policies ($\mathcal{F}_{13}$). Moreover, all flavors of H$\epsilon$lion prove useful ($\mathcal{F}_{14}$), and our experiments indicate that down may be inclined towards generating unnatural but unsafe scenarios ($\mathcal{F}_{8}$). Finally, H$\epsilon$lion’s scenarios have been used to detect two platform and one device flaws, which is another indication of its utility.

Lesson 3: H$\epsilon$lion enables future research opportunities:. H$\epsilon$lion may be modified to model temporal information within sequences (i.e., the time by which two events should be spaced out when executed), which would allow it to model context-shifts in the home ($\mathcal{F}_{12}$). Alternately, future work could also extend our execution engine to allow the evaluator to interactively configure the timing between the events within a scenario, at runtime, based on intuition. Further, future work could modify H$\epsilon$lion to enable a more precise perspective, by adjusting the probability distributions of H$\epsilon$lion’s LMs to predict events for a constrained set of devices (i.e., those specific to a certain smart home).

Lesson 4: We need to study more than IoT apps: Our empirical analysis strongly confirms that routines are important for users ($\mathcal{F}_{1}$), and that users express a strong preference for creating their own routines ($\mathcal{F}_{3}$). Importantly, we observe a significant mismatch between the available IoT apps and routines created by our users ($\mathcal{F}_{2}$). This phenomenon is in complete contrast to app-based platforms such as Android, where users are entirely dependent on apps built by third-party developers. Thus, user-driven home automation may introduce a set of largely unexplored security implications that may not be apparent from just analyzing IoT apps. This paper presents an important take away for future research in home automation security: unlike past research in app-based platforms, the methodology of characterizing the environment solely according to apps published in app markets is not viable for characterizing home automation, as users may not use only IoT apps in favor of easily-created routines.

References Cited

• (1)
• Bo-June Hsu (2018)

Bo-June Hsu. Accessed December 2018.

MIT Language Modeling Toolkit.

https://github.com/mitlm/mitlm.

• Brackenbury et al. (2019)

Will Brackenbury, Abhimanyu Deora, Jillian Ritchey, Jason Vallee, Weijia He, Guan Wang, Michael L. Littman, and Blase Ur. 2019.

How Users Interpret Bugs in Trigger-Action Programming. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems (CHI ’19). ACM, New York, NY, USA, Article 552, 12 pages.

https://doi.org/10.1145/3290605.3300782

• Celik et al. (2018a)

Z Berkay Celik, Leonardo Babun, Amit Kumar Sikder, Hidayet Aksu, Gang Tan, Patrick McDaniel, and A Selcuk Uluagac. 2018a.

Sensitive Information Tracking in Commodity IoT. In Proceedings of the 27th USENIX Security Symposium (USENIX).

• Celik et al. (2018b)

Z. Berkay Celik, Patrick McDaniel, and Gang Tan. 2018b.

Soteria: Automated IoT Safety and Security Analysis. In 2018 USENIX Annual Technical Conference (USENIX ATC). 147–158.

• Celik et al. (2019)

Z. Berkay Celik, Gang Tan, and Patrick McDaniel. 2019.

IoTGuard: Dynamic Enforcement of Security and Safety Policy in Commodity IoT. In 2019 NDSS Symposium.

To appear.

• Chen and Goodman (1999)

Stanley F Chen and Joshua Goodman. 1999.

An empirical study of smoothing techniques for language modeling.

Computer Speech & Language 13, 4 (1999).

• Corno et al. (2019)

Fulvio Corno, Luigi De Russis, and Alberto Monge Roffarello. 2019.

Empowering End Users in Debugging Trigger-Action Rules. In Proceedings of the 2019 CHI Conference on Human Factors in Computing Systems (CHI ’19). ACM, New York, NY, USA, Article 388, 13 pages.

https://doi.org/10.1145/3290605.3300618

• Ding and Hu (2018)

Wenbo Ding and Hongxin Hu. 2018.

On the Safety of IoT Device Physical Interaction Control. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security (CCS). 832–846.

• Fernandes et al. (2016)

Earlence Fernandes, Jaeyeon Jung, and Atul Prakash. 2016.

Security analysis of emerging smart home applications. In Security and Privacy (SP), 2016 IEEE Symposium on. 636–654.

• Heather Pickstock (2019)

Heather Pickstock. Accessed May 2019.

Fire ripped through Bristol house because of cat’s electrical blanket.

https://www.bristolpost.co.uk/news/bristol-news/fire-ripped-through-bristol-house-2336875.

• Hindle et al. (2012)

A. Hindle, E.T. Barr, Z. Su, M. Gabel, and P. Devanbu. 2012.

On the Naturalness of Software. In International Conference on Software Engineering (ICSE’12). 837–847.

• Jia et al. (2017)

Yunhan Jack Jia, Qi Alfred Chen, Shiqi Wang, Amir Rahmati, Earlence Fernandes, Z Morley Mao, Atul Prakash, and Shanghai JiaoTong Unviersity. 2017.

ContexIoT: Towards providing contextual integrity to appified IoT platforms. In Proceedings of the 2017 Network and Distributed System Security Symposium (NDSS).

• Kafle et al. (2019)

Kaushal Kafle, Kevin Moran, Sunil Manandhar, Adwait Nadkarni, and Denys Poshyvanyk. 2019.

A Study of Data Store-based Home Automation. In Proceedings of the 9th ACM Conference on Data and Application Security and Privacy (CODASPY).

• Linares-Vasquez et al. (2015)

Mario Linares-Vasquez, Martin White, Carlos Bernal-Cardenas, Kevin Moran, and Denys Poshyvanyk. 2015.

Mining Android App Usages for Generating Actionable GUI-based Execution Scenarios. In Proceedings of the 12th Working Conference on Mining Software Repositories. 111–122.

• Manning and Schütze (1999)

Christopher D. Manning and Hinrich Schütze. 1999.

Foundations of Statistical Natural Language Processing.

The MIT Press, Cambridge, Massachusetts.

• Mia Sims (2019)

Mia Sims. Accessed May 2019.

Electric blanket blamed for Las Vegas house fire.

https://www.reviewjournal.com/local/local-las-vegas/electric-blanket-blamed-for-las-vegas-house-fire-1567476/.

• Nathalie Sturgeon (2019)

Nathalie Sturgeon. Accessed May 2019.

Fire that left Syrian family homeless started with blanket near baseboard heater.

https://www.cbc.ca/news/canada/new-brunswick/fire-cause-syrian-family-1.5033662.

• Nest Labs (2019)

Nest Labs. Accessed Feb 2019.

Meet the Nest app.

https://nest.com/app/.

• Nest Labs (2018a)

Nest Labs. Accessed June 2018a.

Nest Developers.

https://developers.nest.com///.

• Nest Labs (2018b)

Nest Labs. Accessed June 2018b.

Works with Nest.

https://nest.com/works-with-nest//.

• Nguyen et al. (2018)

Dang Tu Nguyen, Chengyu Song, Zhiyun Qian, Srikanth V. Krishnamurthy, Edward J. M. Colbert, and Patrick McDaniel. 2018.

IotSan: Fortifying the Safety of IoT Systems. In Proceedings of the 14th International Conference on Emerging Networking EXperiments and Technologies (CoNEXT). 191–203.

• Palekar et al. (2019)

Mitali Palekar, Earlence Fernandes, and Franziska Roesner. 2019.

Analysis of the Susceptibility of Smart Home Programming Interfaces to End User Error. In IEEE Workshop on the Internet of Safe Things (SafeThings) (SafeThings’19). ACM, New York, NY, USA.

• Rahman et al. (2019)

Musfiqur Rahman, Dharani Palani, and Peter Rigby. 2019.

Natural Software Revisted. In Proceedings of the 41st International Conference on Software Engineering Companion (ICSE ’19). IEEE Press, Montreal, QC Canada, to appear.

• Samsung (2018)

Samsung. 2018.

Samsung SmartThings SmartApp Public Repository.

https://github.com/SmartThingsCommunity/SmartThingsPublic.

• SmartThings (2018)

SmartThings. Accessed December 2018.

Yale Assure Lock with Bluetooth (Zigbee).

https://www.smartthings.com/products/yale-assure-lock-with-bluetooth-zigbee.

• SmartThings (2019a)

SmartThings. Accessed February 2019a.

SmartThings Classic App.

https://play.google.com/store/apps/details?id=com.smartthings.android.

• SmartThings (2019b)

SmartThings. Accessed February 2019b.

SmartThings Web IDE.

https://graph.api.smartthings.com.

• SmartThings Community (2018a)

SmartThings Community. Accessed December 2018a.

Execution Times Increasing.

https://community.smartthings.com/t/execution-times-increasing/19979.

• SmartThings Community (2018b)

SmartThings Community. Accessed December 2018b.

Help! Old SmartApp automation still running.

https://community.smartthings.com/t/help-old-smartapp-automation-still-running/70213.

• Smartthings Developers (2018)

Smartthings Developers. Accessed June 2018.

Documentation.

http://developer.smartthings.com/.

• SmartThings Support (2018)

SmartThings Support. Accessed June 2018.

Routines in the SmartThings Classic app.

https://support.smartthings.com/hc/en-us/articles/205380034-Routines-in-the-SmartThings-Classic-app.

• Statista (2019)

Statista. Accessed May 2019.

Forecast market size of the global smart home market from 2016 to 2022 (in billion U.S. dollars).

https://www.statista.com/statistics/682204/global-smart-home-market-size/.

• Surbatovich et al. (2017)

Milijana Surbatovich, Jassim Aljuraidan, Lujo Bauer, Anupam Das, and Limin Jia. 2017.

Some Recipes Can Do More Than Spoil Your Appetite: Analyzing the Security and Privacy Risks of IFTTT Recipes. In Proceedings of the 26th International Conference on World Wide Web. 1501–1510.

• Tian et al. (2017)

Yuan Tian, Nan Zhang, Yueh-Hsun Lin, XiaoFeng Wang, Blase Ur, XianZheng Guo, and Patrick Tague. 2017.

SmartAuth: User-Centered Authorization for the Internet of Things. In Proceedings of the 26th USENIX Security Symposium.

• Ur et al. (2014)

Blase Ur, Elyse McManus, Melwyn Pak Yong Ho, and Michael L Littman. 2014.

Practical trigger-action programming in the smart home. In Proceedings of the SIGCHI Conference on Human Factors in Computing Systems. 803–812.

• Wang et al. (2018)

Qi Wang, Wajih Ul Hassan, Adam Bates, and Carl Gunter. 2018.

Fear and Logging in the Internet of Things. In Network and Distributed Systems Symposium.

• Yeti (2018)

Yeti. Accessed June 2018.

Yeti - Simplify the control of your smart home.

https://getyeti.co/.

• Yonomi (2018)

Yonomi. Accessed June 2018.

Yonomi app – Yonomi.

https://www.yonomi.co.

Appendix A Additional Survey Questions

Aside from collecting routines and execution indicators, we asked users additional questions during the survey, illustrated in Figures 12, 11, 10, and 13.

Appendix B Survey Instrument for the Routine Comparison and Sequence Generation Studies

This section provides the survey instrument for the routine comparison (Sec. 7.1) and sequence generation (Sec. 7.2) studies. Specifically, Figure 14 illustrates how routines were shown to evaluators in Sec. 7.1. Similarly, Figure 15 shows a sequence that one of the evaluators was shown, in Sec. 7.2. Finally, we asked evaluators to provide additional feedback regarding why they rated some routines/sequence as reasonable, as shown in Figure 16.

Appendix C Policies generated using H$\epsilon$lion

Table 4 provides the security/safety policies generated using H$\epsilon$lion.