Best practices for a WiFi-connected device WITHOUT Internet connectivity - ssl

Question

The company I work for makes a device that offers a Web-based setup and operation interface via WiFi. The device will typically be used out in the middle of nowhere, so the presence of an existing WiFi network cannot be assumed: the device's WiFi module therefore operates as an Access Point, and serves up the fancy HTML5 web app over HTTP (the only option available with the WiFi module I chose back in 2013, when this was originally implemented).
This worked great at first, but it's slowly falling apart as the Web evolves. Two problems in particular:
Part of the web app involves mapping, and of course it's quite useful to be able to show a "you are here" marker on a map - but Chrome already refuses to support the HTML5 Geolocation API over HTTP (without even an option to explicitly trust the page), and it looks like all the other browsers will follow suit.
The web app is pretty big (and the WiFi module pretty slow), so I use the HTML5 Application Cache feature to get effectively instant page loads after the initial use of the app. Unfortunately, major browsers are already refusing to allow this feature over HTTP, the feature is being deprecated anyway, and it's successor (Service Workers) is explicitly HTTPS-only.
I'm having to redo both the hardware and software of this feature, as the original WiFi module is no longer available. The modules available these days have lots more CPU power and storage (and cost a tenth as much), so it's now practical to do lots of things such as serving the web app over HTTPS. The advice I'm universally seeing for devices like this is to get a proper SSL certificate, but I don't see how that could possibly work in my case:
There will not normally be an Internet connection available when the device is actually in use, so the certificate couldn't be verified.
The device is accessed either by its IP address 192.168.1.1, or via the LLMNR/mDNS name ui.local. SSL certificates are not offered for either type of address.
I need this to work forever - there's no mechanism in place for updating the certificate in the device. Even 10 years (the longest validity that many self-signed certificate generators offer) would be inadequate; I refuse to build planned obsolescence into the device.
It could perhaps be made to sort of work by adding a DNS server to the device, basically making it a captive portal, so that it can be accessed via a normal URL that I can actually buy a SSL certificate for. However, I see lots of potential problems with this:
It fails if the user's computing device is set up with a static DNS server address (8.8.8.8 or whatever), rather than accepting one from DHCP.
It fails if the user actually has an Internet connection at the same time as the device's WiFi connection.
It fails permanently if DNSSEC ever catches on.
There's still the issue of certificate expiration.
That would appear to leave a self-signed certificate as the only workable option, despite all the advice to the contrary. One common objection to them is "you're teaching users to ignore valid security warnings"; I see your point, but what am I supposed to do instead?
Is there some approach I've overlooked, that would let my device continue to work with modern browsers as well as it did back in 2013?

Answer 1

I agree with you that accessing a device in a LAN without public address via HTTPS is tricky problem.
IMHO there should be a special TLS version of addressing those devices, however at the moment no such standard exists.
From my point of view only a self-signed certificate seems feasible. However when you are talking about "self-signed certificate generators" it to gives me a chill because you should never ever equip a a device with a pre-generated self-signed certificate!
This is one of the worst things you could ever do from a security perspective because pre-generated certificates and key pairs can always be extracted from the firmware and then used to attack one of your customers (Lenovo and other computer manufactures just learned that in the last years the hard way)!
When it comes to self-signed certificates there is only one way:
When the device first start-up wait until enough data has been processed (seeding) so that the random generator can generate secure random data.
Generate a public/private key pair using the generated random data
Generate a self-signed certificate using the previously generated key-pair. Using the right command you can set the validity end to any date you want.
Note that you can re-do step 3 at any time, e.g. when the user reconfigures the IP-address and you have to update that in the certificate. For self-developed clients (e.g. on Android or iOS) you could do public key pinning which would mean that the certificate does not have to be (re)installed.
Unfortunately for web browsers a new certificate even with the same public key means that you have to re-install the certificate as trusted.
Regarding the HTML5 Geolocation API: Can't you use this API via HTTPS? Mixed content is only a problem if you use HTTP resources in a HTTPS page, but the other way round there should not be a problem.
BTW: I found some slides that may be interesting for you, even if in that scenario Internet access is possible. May be you get some new ideas from it: https://www.w3.org/wiki/images/6/6c/TPAC2016_Local_Discovery_and_HTTPS.pdf

Answer 2

You can specify any expiration on a self-signed certificate that you want. It's a parameter to openssl (-days).
The following cert expires in 100 years:
openssl x509 -in localhost.pem -text -noout
Certificate:
Data:
Version: 3 (0x2)
Serial Number:
c2:a8:fc:a1:29:02:96:dd
Signature Algorithm: sha256WithRSAEncryption
Issuer: C = US, ST = New York, L = New York, O = localhost, OU = Testing Domain, CN = localhost
Validity
Not Before: Apr 7 02:25:51 2018 GMT
Not After : Mar 14 02:25:51 2118 GMT
Subject: C = US, ST = New York, L = New York, O = localhost, OU = Testing Domain, CN = localhost
Subject Public Key Info:
Public Key Algorithm: rsaEncryption
Public-Key: (2048 bit)
Modulus:
00:96:89:c9:b4:8f:c0:2e:4c:92:15:cd:df:23:b2:
f1:6f:34:95:ca:e2:a4:c2:95:3f:1f:b3:50:56:16:
65:5a:1a:b9:99:6b:19:67:f0:13:54:76:23:4c:cd:
f5:2a:25:6c:d2:e0:67:e9:d5:34:0e:8f:2d:2b:dc:
04:3f:bb:e4:07:bd:a4:7a:ee:58:87:6b:cc:b7:1e:
79:fc:fc:bd:81:c7:e0:24:1d:91:14:50:70:5b:60:
13:ad:c7:eb:fb:67:3b:a9:e5:83:33:fb:ef:f4:26:
00:12:e3:af:e9:1e:e9:a2:5b:d1:98:3c:13:c0:30:
f0:13:9c:52:a3:b1:e7:3a:73:47:ce:ab:f9:5f:c4:
ff:74:1e:0c:86:ec:83:d6:b5:6d:36:31:00:26:97:
d8:74:39:cb:75:24:31:39:cc:e4:a1:78:38:92:07:
b4:a5:06:5a:8e:8b:0c:fa:7e:5e:55:7e:59:cf:f1:
1f:05:2e:e6:c2:6a:cf:4c:03:6a:66:b8:19:64:ae:
90:81:d9:28:37:2f:09:c1:b3:98:8a:bf:39:0a:0b:
23:db:55:79:02:83:fe:9d:be:ac:b8:3c:e5:1e:76:
5c:69:fe:f4:34:78:d4:36:82:0f:6e:c1:19:fe:39:
7f:fd:f0:4f:13:b6:2a:26:e6:ce:b0:fd:51:3d:38:
61:41
Exponent: 65537 (0x10001)
X509v3 extensions:
X509v3 Subject Key Identifier:
D6:DF:EB:FA:73:85:C9:22:AA:6D:79:E5:F9:16:01:2B:CC:E7:D8:D0
X509v3 Authority Key Identifier:
keyid:D6:DF:EB:FA:73:85:C9:22:AA:6D:79:E5:F9:16:01:2B:CC:E7:D8:D0
X509v3 Basic Constraints: critical
CA:TRUE
Signature Algorithm: sha256WithRSAEncryption
4f:ca:30:3f:fe:61:73:16:3f:a1:6d:5a:35:c1:b6:97:d6:63:
89:34:6e:05:e6:e6:84:7b:3b:b4:fc:89:65:7a:31:46:97:8f:
00:11:c7:61:97:86:b8:31:c7:a7:91:f7:c9:19:4e:0a:39:d7:
5e:95:52:17:92:8a:84:ce:6a:1b:1c:14:f2:15:18:62:78:07:
1e:d9:3c:5d:9c:28:65:42:bf:4f:61:0f:a3:86:e6:ff:38:34:
23:97:11:20:3c:5b:82:4a:ea:05:af:6d:5e:83:30:be:6d:64:
de:85:b8:bb:89:60:59:7a:c8:1f:ba:2d:02:04:34:89:65:32:
2c:10:f7:db:97:c3:ba:e2:ed:27:8a:bb:8d:9e:92:0a:d3:2e:
ad:9e:fb:15:fc:25:73:0d:e2:f9:45:3b:18:fd:89:e6:6b:31:
18:64:46:e2:dc:ad:e0:f3:f8:c1:b2:e6:93:bc:b3:db:9a:bc:
d3:58:38:68:e2:28:b4:6d:ca:07:d8:af:21:dc:10:bd:c0:75:
3f:b1:d2:24:96:5d:dd:a3:d2:e2:95:39:67:6b:06:bb:4d:91:
76:4f:9b:ce:7f:25:39:47:73:3e:fd:81:82:15:ac:6a:2c:cb:
82:76:04:b1:91:41:cf:8a:68:70:cd:7d:3f:2f:c9:1d:d5:a7:
3e:d0:3d:00
You can generate it with the following script:
#! /bin/bash
mkdir /tmp/scert 2>/dev/null
rm -r /tmp/scert/* 2>/dev/null
if [ $# -ne 1 ];
then
echo "Usage: scert <name>"
exit
fi
if [ -e "/etc/ssl/private/$1.key" ];
then
echo "/etc/ssl/private/$1.key already exists"
exit
fi
if [ -e "/etc/ssl/certs/$1.crt" ];
then
echo "/etc/ssl/certs/$1.crt already exists"
exit
fi
if [ -e "/etc/ssl/certs/$1.pem" ];
then
echo "/etc/ssl/certs/$1.pem already exists"
exit
fi
echo "[req]" > /tmp/scert/tmp.cnf
echo "default_bits = 2048" >> /tmp/scert/tmp.cnf
echo "prompt = no" >> /tmp/scert/tmp.cnf
echo "default_md = sha256" >> /tmp/scert/tmp.cnf
echo "distinguished_name = dn" >> /tmp/scert/tmp.cnf
echo "" >> /tmp/scert/tmp.cnf
echo "[dn]" >> /tmp/scert/tmp.cnf
echo "C=US" >> /tmp/scert/tmp.cnf
echo "ST=New York" >> /tmp/scert/tmp.cnf
echo "L=Rochester" >> /tmp/scert/tmp.cnf
echo "O=$1" >> /tmp/scert/tmp.cnf
echo "OU=Testing Domain" >> /tmp/scert/tmp.cnf
echo "emailAddress=spam#uce.gov" >> /tmp/scert/tmp.cnf
echo "CN = localhost" >> /tmp/scert/tmp.cnf
echo "authorityKeyIdentifier=keyid,issuer" > /tmp/scert/tmp.ext
echo "basicConstraints=CA:FALSE" >> /tmp/scert/tmp.ext
echo "keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment" >> /tmp/scert/tmp.ext
echo "subjectAltName = #alt_names" >> /tmp/scert/tmp.ext
echo "" >> /tmp/scert/tmp.ext
echo "[alt_names]" >> /tmp/scert/tmp.ext
echo "DNS.1 = localhost" >> /tmp/scert/tmp.ext
openssl genrsa -des3 -passout pass:xxxx -out /tmp/scert/tmp.pass.key 2048
openssl rsa -passin pass:xxxx -in "/tmp/scert/tmp.pass.key" -out "/tmp/scert/tmp.key"
openssl req -x509 -new -nodes -key /tmp/scert/tmp.key -subj "/C=US/ST=New York/L=New York/O=$1/OU=Testing Domain/CN=localhost" -sha256 -days 36500 -out /tmp/scert/$1.pem
openssl req -new -sha256 -nodes -out /tmp/scert/tmp.csr -newkey rsa:2048 -keyout /tmp/scert/$1.key -config <( cat /tmp/scert/tmp.cnf )
openssl x509 -req -in /tmp/scert/tmp.csr -CA /tmp/scert/$1.pem -CAkey /tmp/scert/tmp.key -CAcreateserial -out /tmp/scert/$1.crt -days 36500 -sha256 -extfile /tmp/scert/tmp.ext
if [ -e "/tmp/scert/$1.key" ];
then
sudo cp /tmp/scert/$1.key /etc/ssl/private
sudo chown root:ssl-cert /etc/ssl/private/$1.key
sudo chmod 640 /etc/ssl/private/$1.key
ls -al /etc/ssl/private/$1.key
else
echo "ERROR: /tmp/scert/$1.key not found"
fi
if [ -e "/tmp/scert/$1.crt" ];
then
sudo cp /tmp/scert/$1.crt /etc/ssl/certs
sudo chown root:root /etc/ssl/certs/$1.crt
sudo chmod 755 /etc/ssl/certs/$1.crt
ls -al /etc/ssl/certs/$1.crt
else
echo "ERROR: /tmp/scert/$1.crt not found"
fi
if [ -e "/tmp/scert/$1.pem" ];
then
sudo cp /tmp/scert/$1.pem /etc/ssl/certs
sudo chown root:root /etc/ssl/certs/$1.pem
sudo chmod 755 /etc/ssl/certs/$1.pem
ls -al /etc/ssl/certs/$1.pem
else
echo "ERROR: /tmp/scert/$1.pem not found"
fi
rm -r /tmp/scert/* 2>/dev/null
echo "DONE"