aboutsummaryrefslogtreecommitdiff
path: root/utils/last_gasp_default_pin
blob: 50d822fa8f33be2eb300447702188f9e852eb730 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
#!/usr/bin/env python

"""
Somewhere, the HSM has to have a last-gasp default PIN, even if it's
only the null string, because there has to be **some** way to
initialize the poor thing.  Absent a better plan (feel free to
suggest one!), this last-gasp default is compiled in.

The normal value of this last-gasp PIN is deliberately chosen to be
annoying, so that people will change it, but since the derevation
requires running PBKDF2 and you might want a different default if
you're compiling this for yourself, we provide the script that
generates the default.
"""

# Author: Rob Austein
# Copyright (c) 2016, NORDUnet A/S
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
# - Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
#
# - Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in the
#   documentation and/or other materials provided with the distribution.
#
# - Neither the name of the NORDUnet nor the names of its contributors may
#   be used to endorse or promote products derived from this software
#   without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
# IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
# TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
# PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
# NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

from argparse                   import ArgumentParser, ArgumentDefaultsHelpFormatter
from os                         import urandom
from Crypto.Protocol.KDF        import PBKDF2
from Crypto.Hash                import SHA256, HMAC

parser = ArgumentParser(description = __doc__, formatter_class = ArgumentDefaultsHelpFormatter)
parser.add_argument("-p", "--pin",
                    default = "YouReallyNeedToChangeThisPINRightNowWeAreNotKidding",
                    help    = "PIN plaintext before PBKDF2 processing")
parser.add_argument("-i", "--iterations",
                    type    = int,
                    default = 10000,
                    help    = "PBKDF2 iteration count")
parser.add_argument("-d", "--derived-key-length",
                    type    = int,
                    default = 64,
                    help    = "length of PBKDF2 output (must match libhal)")
args = parser.parse_args()

def HMAC_SHA256(pin, salt):
    return HMAC.new(pin, salt, SHA256).digest()

def hexify(value):
    return ", ".join("0x%02x" % ord(v) for v in value)

salt = urandom(16)

pin  = PBKDF2(password = args.pin,
              salt     = salt,
              dkLen    = args.derived_key_length,
              count    = args.iterations,
              prf      = HMAC_SHA256)

print '''\
/*
 * Automatically generated by a script, do not edit.
 */

static const hal_ks_pin_t hal_last_gasp_pin = {{
  {iterations},
  {{{pin}}},
  {{{salt}}}
}};'''.format(iterations = args.iterations,
              pin        = hexify(pin),
              salt       = hexify(salt))
on_handle_t session; hal_ks_block_t block; } ks_volatile_key_t; typedef struct { hal_ks_t ks; /* Must be first */ ks_volatile_key_t *keys; } ks_volatile_db_t; /* * This is a bit silly, but it's safe enough, and it lets us avoid a * nasty mess of forward references. */ #define db ((ks_volatile_db_t * const) hal_ks_volatile) /* * Read a block. CRC probably not necessary for RAM. */ static hal_error_t ks_volatile_read(hal_ks_t *ks, const unsigned blockno, hal_ks_block_t *block) { if (ks != hal_ks_volatile || db->keys == NULL || block == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; memcpy(block, &db->keys[blockno].block, sizeof(*block)); return HAL_OK; } /* * Convert a live block into a tombstone. */ static hal_error_t ks_volatile_deprecate(hal_ks_t *ks, const unsigned blockno) { if (ks != hal_ks_volatile || db->keys == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; db->keys[blockno].block.header.block_status = HAL_KS_BLOCK_STATUS_TOMBSTONE; return HAL_OK; } /* * Zero (not erase) a flash block. */ static hal_error_t ks_volatile_zero(hal_ks_t *ks, const unsigned blockno) { if (ks != hal_ks_volatile || db->keys == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; memset(&db->keys[blockno].block, 0x00, sizeof(db->keys[blockno].block)); db->keys[blockno].client.handle = HAL_HANDLE_NONE; db->keys[blockno].session.handle = HAL_HANDLE_NONE; return HAL_OK; } /* * Erase a flash block. */ static hal_error_t ks_volatile_erase(hal_ks_t *ks, const unsigned blockno) { if (ks != hal_ks_volatile || db->keys == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; memset(&db->keys[blockno].block, 0xFF, sizeof(db->keys[blockno].block)); db->keys[blockno].client.handle = HAL_HANDLE_NONE; db->keys[blockno].session.handle = HAL_HANDLE_NONE; return HAL_OK; } /* * Write a flash block. CRC probably not necessary for RAM. */ static hal_error_t ks_volatile_write(hal_ks_t *ks, const unsigned blockno, hal_ks_block_t *block) { if (ks != hal_ks_volatile || db->keys == NULL || block == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; memcpy(&db->keys[blockno].block, block, sizeof(*block)); return HAL_OK; } /* * Set key ownership. */ static hal_error_t ks_volatile_set_owner(hal_ks_t *ks, const unsigned blockno, const hal_client_handle_t client, const hal_session_handle_t session) { if (ks != hal_ks_volatile || db->keys == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; db->keys[blockno].client = client; db->keys[blockno].session = session; return HAL_OK; } /* * Test key ownership. * * One might expect this to be based on whether the session matches, * and indeed it would be in a sane world, but in the world of PKCS * #11, keys belong to sessions, are visible to other sessions, and * may even be modifiable by other sessions, but softly and silently * vanish away when the original creating session is destroyed. * * In our terms, this means that visibility of session objects is * determined only by the client handle, so taking the session handle * as an argument here isn't really necessary, but we've flipflopped * on that enough times that at least for now I'd prefer to leave the * session handle here and not have to revise all the RPC calls again. * Remove it at some later date and redo the RPC calls if we manage to * avoid revising this yet again. */ static hal_error_t ks_volatile_test_owner(hal_ks_t *ks, const unsigned blockno, const hal_client_handle_t client, const hal_session_handle_t session) { if (ks != hal_ks_volatile || db->keys == NULL || blockno >= ks->size) return HAL_ERROR_IMPOSSIBLE; if (db->keys[blockno].client.handle == HAL_HANDLE_NONE || db->keys[blockno].client.handle == client.handle) return HAL_OK; if (hal_rpc_is_logged_in(client, HAL_USER_WHEEL) == HAL_OK) return HAL_OK; return HAL_ERROR_KEY_NOT_FOUND; } /* * Copy key ownership. */ static hal_error_t ks_volatile_copy_owner(hal_ks_t *ks, const unsigned source, const unsigned target) { if (ks != hal_ks_volatile || db->keys == NULL || source >= ks->size || target >= ks->size) return HAL_ERROR_IMPOSSIBLE; db->keys[target].client = db->keys[source].client; db->keys[target].session = db->keys[source].session; return HAL_OK; } /* * Zero any blocks owned by a client that we're logging out. */ static hal_error_t ks_volatile_logout(hal_ks_t *ks, hal_client_handle_t client) { if (ks != hal_ks_volatile || client.handle == HAL_HANDLE_NONE) return HAL_ERROR_IMPOSSIBLE; for (unsigned i = 0; i < ks->used; i++) { unsigned b = ks->index[i]; hal_error_t err; int hint = i; if (db->keys[b].client.handle != client.handle) continue; if ((err = hal_ks_index_delete(ks, &ks->names[b], NULL, &hint)) != HAL_OK || (err = hal_ks_block_zero(ks, b)) != HAL_OK) return err; i--; } return HAL_OK; } /* * Initialize keystore. */ static hal_error_t ks_volatile_init(hal_ks_t *ks, const int alloc) { if (ks != hal_ks_volatile) return HAL_ERROR_IMPOSSIBLE; void *mem = NULL; hal_error_t err; if (alloc && (err = hal_ks_alloc_common(ks, HAL_STATIC_KS_VOLATILE_SLOTS, KS_VOLATILE_CACHE_SIZE, &mem, sizeof(*db->keys) * HAL_STATIC_KS_VOLATILE_SLOTS)) != HAL_OK) return err; if (alloc) db->keys = mem; if (db->keys == NULL) return HAL_ERROR_IMPOSSIBLE; for (unsigned b = 0; b < db->ks.size; b++) if ((err = hal_ks_block_erase(ks, b)) != HAL_OK) return err; if ((err = hal_ks_init_common(ks)) != HAL_OK) return err; return HAL_OK; } /* * Dispatch vector and keystore definition, now that we've defined all * the driver functions. */ static const hal_ks_driver_t ks_volatile_driver = { .init = ks_volatile_init, .read = ks_volatile_read, .write = ks_volatile_write, .deprecate = ks_volatile_deprecate, .zero = ks_volatile_zero, .erase = ks_volatile_erase, .erase_maybe = ks_volatile_erase, /* sic */ .set_owner = ks_volatile_set_owner, .test_owner = ks_volatile_test_owner, .copy_owner = ks_volatile_copy_owner, .logout = ks_volatile_logout }; static ks_volatile_db_t _db = { .ks.driver = &ks_volatile_driver }; hal_ks_t * const hal_ks_volatile = &_db.ks; /* * Local variables: * indent-tabs-mode: nil * End: */