Properly verify Device ID's entered by the user synchronously

[Catfriend1]

Better validate Device ID's (if possible)

Information is here:
syncthing/syncthing#4217
https://docs.syncthing.net/dev/device-ids.html
https://forum.syncthing.net/t/v0-9-0-new-node-id-format/478/3
https://github.com/syncthing/syncthing/blob/master/lib/protocol/deviceid.go
https://github.com/syncthing/syncthing/blob/master/lib/protocol/luhn.go

[Catfriend1]

Quote:

3.5.2. Device IDs
To form a device ID the SHA-256 hash of the certificate data in DER form is calculated. This means the hash covers all information under the Certificate: section above.
The hashing results in a 256 bit hash which we encode using base32. Base32 encodes five bits per character so we need 256 / 5 = 51.2 characters to encode the device ID. This becomes 52 characters in practice, but 52 characters of base32 would decode to 260 bits which is not a whole number of bytes. The base32 encoding adds padding to 280 bits (the next multiple of both 5 and 8 bits) so the resulting ID looks something like:
MFZWI3DBONSGYYLTMRWGC43ENRQXGZDMMFZWI3DBONSGYYLTMRWA====
The padding (====) is stripped away, the device ID split into four groups, and check digits are added for each group. For presentation purposes the device ID is grouped with dashes, resulting in the final value:
MFZWI3D-BONSGYC-YLTMRWG-C43ENR5-QXGZDMM-FZWI3DP-BONSGYY-LTMRWAD
Here's a one liner for you:
$ openssl x509 -in cert.pem -outform der
| openssl sha -sha256 -binary
| python -c 'import base64; import sys; print(base64.b32encode(sys.stdin.read()))'
| tr -d =
SYNO4VLTKVFF2QKC2T3VTTK4BGD2ZA5OTPDKSI33P4JQVSBL4VXA
That gets you the device ID, without dashes and check digits. Nonetheless this format is accepted by Syncthing, in the config, API, and GUI.
If you have a running Syncthing, any Syncthing, this can be posted to /rest/svc/deviceid to get the format verified and corrected with check digits and stuff.
$ curl -s -H X-API-Key:abcd123 http://localhost:8385/rest/svc/deviceid?id=SYNO4VLTKVFF2QKC2T3VTTK4BGD2ZA5OTPDKSI33P4JQVSBL4VXA
| json id
SYNO4VL-TKVFF25-QKC2T3V-TTK4BGU-D2ZA5OT-PDKSI3R-3P4JQVS-BL4VXAC
This last bit is the "proprietary" part so I can't shell-one-linerize it easily, although I'm sure all the components are available in Python. But you don't need it. I personally guarantee that the original dashless device ID format will be accepted for as long as this kind of device ID is in use at all.

func (n *DeviceID) UnmarshalText(bs []byte) error {
	id := string(bs)
	id = strings.Trim(id, "=")
	id = strings.ToUpper(id)
	id = untypeoify(id)
	id = unchunkify(id)

	var err error
	switch len(id) {
	case 0:
		*n = EmptyDeviceID
		return nil
	case 56:
		// New style, with check digits
		id, err = unluhnify(id)
		if err != nil {
			return err
		}
		fallthrough
	case 52:
		// Old style, no check digits
		dec, err := base32.StdEncoding.DecodeString(id + "====")
		if err != nil {
			return err
		}
		copy(n[:], dec)
		return nil
	default:
		return fmt.Errorf("%q: device ID invalid: incorrect length", bs)
	}
}

func unluhnify(s string) (string, error) {
	if len(s) != 56 {
		return "", fmt.Errorf("%q: unsupported string length %d", s, len(s))
	}

	res := make([]byte, 52)
	for i := 0; i < 4; i++ {
		p := s[i*(13+1) : (i+1)*(13+1)-1]
		copy(res[i*13:], p)
		l, err := luhnBase32.generate(p)
		if err != nil {
			return "", err
		}
		if s[(i+1)*14-1] != byte(l) {
			return "", fmt.Errorf("%q: check digit incorrect", s)
		}
	}
	return string(res), nil
}

[Catfriend1]

v0.9 introduces a new format for node ID:s. It’s quite similar to the old one. The old format:

P56IOI-7MZJNU-2IQGDR-EYDM2M-GTMGL3-BXNPQ6-W5BTBB-Z4TJXZ-WICQ
And the new format:

P56IOI7-MZJNU2Y-IQGDREY-DM2MGTI-MGL3BXN-PQ6W5BM-TBBZ4TJ-XZWICQ2
The differences are:

There are four more characters (56 vs the old 52). The extra bits of data are check characters. When a node ID is input or loaded from configuration, the check characters are verified to make sure the node ID has been correctly copied.

The grouping is changed to groups of seven. This nicely divides the new node ID into eight equal groups.

The placement of the check digits are as follows:

aaaaaaa-aaaaaaA-bbbbbbb-bbbbbbB-ccccccc-ccccccC-ddddddd-ddddddD
aaaaaaa-aaaaaa are data, checked by the immediately following A character, and similarly for b, c, and d. That is, each two seven-character groups contain their own check digit.

The GUI will provide some useful feedback (i.e. green/red letter groups) when entering a node ID, based on the correctness of the check digits.

The console logs and configuration now all contain the new format node ID:s (with the configuration accepting the old format as well).

Trivial copying errors (O to 0, I to 1 and B to 8) are corrected silently and automatically.