tree 6273f2b255f23b9711930498ae1e261edeb5caa6
parent d52f7bbb73401aab8a1d59e8d0d686ad9641035e
author dann frazier <dann.frazier@canonical.com> 1597267628 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1597777599 -0700

sbkeysync: Don't ignore errors from insert_new_keys()

If insert_new_keys() fails, say due to a full variable store, we currently
still exit(0). This can make it difficult to know something is wrong.
For example, Debian and Ubuntu implement a secureboot-db systemd service
to update the DB and DBX, which calls:

 ExecStart=/usr/bin/sbkeysync --no-default-keystores --keystore /usr/share/secureboot/updates --verbose

But although this seemed to succeed on my system, looking at the logs shows
a different story:

Inserting key update /usr/share/secureboot/updates/dbx/dbxupdate_x64.bin into dbx
Error writing key update: Invalid argument
Error syncing keystore file /usr/share/secureboot/updates/dbx/dbxupdate_x64.bin

Signed-off-by: dann frazier <dann.frazier@canonical.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
