614 lines
11 KiB
C
614 lines
11 KiB
C
/*
|
||
* authkeys.c - routines to manage the storage of authentication keys
|
||
*/
|
||
#include <stdio.h>
|
||
|
||
#include "ntp_types.h"
|
||
#include "ntp_string.h"
|
||
#include "ntp_malloc.h"
|
||
#include "ntp_stdlib.h"
|
||
|
||
/*
|
||
* Structure to store keys in in the hash table.
|
||
*/
|
||
struct savekey {
|
||
struct savekey *next;
|
||
union {
|
||
long bogon; /* Make sure union isn't empty... */
|
||
#ifdef DES
|
||
u_int32 DES_key[2];
|
||
#endif
|
||
#ifdef MD5
|
||
char MD5_key[32];
|
||
#endif
|
||
} k;
|
||
u_long keyid;
|
||
u_short flags;
|
||
#ifdef MD5
|
||
int keylen;
|
||
#endif
|
||
};
|
||
|
||
#define KEY_TRUSTED 0x1 /* this key is trusted */
|
||
#define KEY_KNOWN 0x2 /* this key is known */
|
||
|
||
#ifdef DES
|
||
#define KEY_DES 0x100 /* this is a DES type key */
|
||
#endif
|
||
|
||
#ifdef MD5
|
||
#define KEY_MD5 0x200 /* this is a MD5 type key */
|
||
#endif
|
||
|
||
/*
|
||
* The hash table. This is indexed by the low order bits of the
|
||
* keyid. We make this fairly big for potentially busy servers.
|
||
*/
|
||
#define HASHSIZE 64
|
||
#define HASHMASK ((HASHSIZE)-1)
|
||
#define KEYHASH(keyid) ((keyid) & HASHMASK)
|
||
|
||
struct savekey *key_hash[HASHSIZE];
|
||
|
||
u_int32 authkeynotfound;
|
||
u_int32 authkeylookups;
|
||
u_int32 authnumkeys;
|
||
u_int32 authuncached;
|
||
u_int32 authkeyuncached;
|
||
u_int32 authnokey; /* calls to encrypt with no key */
|
||
u_int32 authencryptions;
|
||
u_int32 authdecryptions;
|
||
|
||
/*
|
||
* Storage for free key structures. We malloc() such things but
|
||
* never free them.
|
||
*/
|
||
struct savekey *authfreekeys;
|
||
int authnumfreekeys;
|
||
|
||
#define MEMINC 12 /* number of new free ones to get at once */
|
||
|
||
|
||
#ifdef DES
|
||
/*
|
||
* Size of the key schedule (in u_longs for fast DES)
|
||
*/
|
||
#define KEY_SCHED_SIZE ((128+sizeof(u_long)-1)/sizeof(u_long))
|
||
|
||
/*
|
||
* The zero key, which we always have. Store the permutted key
|
||
* zero in here.
|
||
*/
|
||
#define ZEROKEY_L 0x01010101 /* odd parity zero key */
|
||
#define ZEROKEY_R 0x01010101 /* right half of same */
|
||
/*
|
||
* fast DES code expects base address aligned to u_long
|
||
*/
|
||
u_long DESzeroekeys[KEY_SCHED_SIZE];
|
||
u_long DESzerodkeys[KEY_SCHED_SIZE];
|
||
u_long DEScache_ekeys[KEY_SCHED_SIZE];
|
||
u_long DEScache_dkeys[KEY_SCHED_SIZE];
|
||
#endif
|
||
|
||
/*
|
||
* The key cache. We cache the last key we looked at here.
|
||
*/
|
||
u_long cache_keyid;
|
||
u_short cache_flags;
|
||
|
||
#ifdef MD5
|
||
int cache_keylen;
|
||
char *cache_key;
|
||
#endif
|
||
|
||
/*
|
||
* init_auth - initialize internal data
|
||
*/
|
||
void
|
||
init_auth()
|
||
{
|
||
#ifdef DES
|
||
u_int32 zerokey[2];
|
||
#endif
|
||
|
||
/*
|
||
* Initialize hash table and free list
|
||
*/
|
||
memset((char *)key_hash, 0, sizeof key_hash);
|
||
cache_keyid = 0;
|
||
cache_flags = 0;
|
||
|
||
authnumfreekeys = authkeynotfound = authkeylookups = 0;
|
||
authnumkeys = authuncached = authkeyuncached = authnokey = 0;
|
||
authencryptions = authdecryptions = 0;
|
||
|
||
#ifdef DES
|
||
/*
|
||
* Initialize the zero key
|
||
*/
|
||
zerokey[0] = ZEROKEY_L;
|
||
zerokey[1] = ZEROKEY_R;
|
||
/* could just zero all */
|
||
DESauth_subkeys(zerokey, (u_char *)DESzeroekeys, (u_char *)DESzerodkeys);
|
||
#endif
|
||
}
|
||
|
||
|
||
/*
|
||
* auth_findkey - find a key in the hash table
|
||
*/
|
||
struct savekey *
|
||
auth_findkey(keyno)
|
||
u_long keyno;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid)
|
||
return sk;
|
||
sk = sk->next;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*
|
||
* auth_havekey - return whether a key is known
|
||
*/
|
||
int
|
||
auth_havekey(keyno)
|
||
u_long keyno;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
if (keyno == 0 || (keyno == cache_keyid))
|
||
return 1;
|
||
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid) {
|
||
if (sk->flags & KEY_KNOWN)
|
||
return 1;
|
||
else {
|
||
authkeynotfound++;
|
||
return 0;
|
||
}
|
||
}
|
||
sk = sk->next;
|
||
}
|
||
authkeynotfound++;
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*
|
||
* authhavekey - return whether a key is known. Permute and cache
|
||
* the key as a side effect.
|
||
*/
|
||
int
|
||
authhavekey(keyno)
|
||
u_long keyno;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
authkeylookups++;
|
||
if (keyno == 0 || keyno == cache_keyid)
|
||
return 1;
|
||
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid)
|
||
break;
|
||
sk = sk->next;
|
||
}
|
||
|
||
if (sk == 0 || !(sk->flags & KEY_KNOWN)) {
|
||
authkeynotfound++;
|
||
return 0;
|
||
}
|
||
|
||
cache_keyid = sk->keyid;
|
||
cache_flags = sk->flags;
|
||
#ifdef MD5
|
||
if (sk->flags & KEY_MD5) {
|
||
cache_keylen = sk->keylen;
|
||
cache_key = (char *) sk->k.MD5_key; /* XXX */
|
||
return 1;
|
||
}
|
||
#endif
|
||
|
||
#ifdef DES
|
||
if (sk->flags & KEY_DES) {
|
||
DESauth_subkeys(sk->k.DES_key, (u_char *)DEScache_ekeys, (u_char *)DEScache_dkeys);
|
||
return 1;
|
||
}
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*
|
||
* auth_moremem - get some more free key structures
|
||
*/
|
||
int
|
||
auth_moremem()
|
||
{
|
||
register struct savekey *sk;
|
||
register int i;
|
||
|
||
sk = (struct savekey *)malloc(MEMINC * sizeof(struct savekey));
|
||
if (sk == 0)
|
||
return 0;
|
||
|
||
for (i = MEMINC; i > 0; i--) {
|
||
sk->next = authfreekeys;
|
||
authfreekeys = sk++;
|
||
}
|
||
authnumfreekeys += MEMINC;
|
||
return authnumfreekeys;
|
||
}
|
||
|
||
|
||
/*
|
||
* authtrust - declare a key to be trusted/untrusted
|
||
*/
|
||
void
|
||
authtrust(keyno, trust)
|
||
u_long keyno;
|
||
int trust;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid)
|
||
break;
|
||
sk = sk->next;
|
||
}
|
||
|
||
if (sk == 0 && !trust)
|
||
return;
|
||
|
||
if (sk != 0) {
|
||
if (cache_keyid == keyno) {
|
||
cache_flags = 0;
|
||
cache_keyid = 0;
|
||
}
|
||
|
||
if (trust) {
|
||
sk->flags |= KEY_TRUSTED;
|
||
return;
|
||
}
|
||
|
||
sk->flags &= ~KEY_TRUSTED;
|
||
if (!(sk->flags & KEY_KNOWN)) {
|
||
register struct savekey *skp;
|
||
|
||
skp = key_hash[KEYHASH(keyno)];
|
||
if (skp == sk) {
|
||
key_hash[KEYHASH(keyno)] = sk->next;
|
||
} else {
|
||
while (skp->next != sk)
|
||
skp = skp->next;
|
||
skp->next = sk->next;
|
||
}
|
||
authnumkeys--;
|
||
|
||
sk->next = authfreekeys;
|
||
authfreekeys = sk;
|
||
authnumfreekeys++;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (authnumfreekeys == 0)
|
||
if (auth_moremem() == 0)
|
||
return;
|
||
|
||
sk = authfreekeys;
|
||
authfreekeys = sk->next;
|
||
authnumfreekeys--;
|
||
|
||
sk->keyid = keyno;
|
||
sk->flags = KEY_TRUSTED;
|
||
sk->next = key_hash[KEYHASH(keyno)];
|
||
key_hash[KEYHASH(keyno)] = sk;
|
||
authnumkeys++;
|
||
return;
|
||
}
|
||
|
||
|
||
/*
|
||
* authistrusted - determine whether a key is trusted
|
||
*/
|
||
int
|
||
authistrusted(keyno)
|
||
u_long keyno;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
if (keyno == cache_keyid)
|
||
return ((cache_flags & KEY_TRUSTED) != 0);
|
||
|
||
authkeyuncached++;
|
||
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid)
|
||
break;
|
||
sk = sk->next;
|
||
}
|
||
|
||
if (sk == 0 || !(sk->flags & KEY_TRUSTED))
|
||
return 0;
|
||
return 1;
|
||
}
|
||
|
||
|
||
|
||
#ifdef DES
|
||
/*
|
||
* DESauth_setkey - set a key into the key array
|
||
*/
|
||
void
|
||
DESauth_setkey(keyno, key)
|
||
u_long keyno;
|
||
const u_int32 *key;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
/*
|
||
* See if we already have the key. If so just stick in the
|
||
* new value.
|
||
*/
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid) {
|
||
sk->k.DES_key[0] = key[0];
|
||
sk->k.DES_key[1] = key[1];
|
||
sk->flags |= KEY_KNOWN | KEY_DES;
|
||
if (cache_keyid == keyno)
|
||
cache_flags = 0;
|
||
cache_keyid = 0;
|
||
return;
|
||
}
|
||
sk = sk->next;
|
||
}
|
||
|
||
/*
|
||
* Need to allocate new structure. Do it.
|
||
*/
|
||
if (authnumfreekeys == 0) {
|
||
if (auth_moremem() == 0)
|
||
return;
|
||
}
|
||
|
||
sk = authfreekeys;
|
||
authfreekeys = sk->next;
|
||
authnumfreekeys--;
|
||
|
||
sk->k.DES_key[0] = key[0];
|
||
sk->k.DES_key[1] = key[1];
|
||
sk->keyid = keyno;
|
||
sk->flags = KEY_KNOWN | KEY_DES;
|
||
sk->next = key_hash[KEYHASH(keyno)];
|
||
key_hash[KEYHASH(keyno)] = sk;
|
||
authnumkeys++;
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
#ifdef MD5
|
||
void
|
||
MD5auth_setkey(keyno, key)
|
||
u_long keyno;
|
||
const u_int32 *key;
|
||
{
|
||
register struct savekey *sk;
|
||
|
||
/*
|
||
* See if we already have the key. If so just stick in the
|
||
* new value.
|
||
*/
|
||
sk = key_hash[KEYHASH(keyno)];
|
||
while (sk != 0) {
|
||
if (keyno == sk->keyid) {
|
||
strncpy(sk->k.MD5_key, (char *)key, sizeof(sk->k.MD5_key));
|
||
if ((sk->keylen = strlen((char *)key)) >
|
||
sizeof(sk->k.MD5_key))
|
||
sk->keylen = sizeof(sk->k.MD5_key);
|
||
|
||
sk->flags |= KEY_KNOWN | KEY_MD5;
|
||
if (cache_keyid == keyno) {
|
||
cache_flags = 0;
|
||
cache_keyid = 0;
|
||
}
|
||
return;
|
||
}
|
||
sk = sk->next;
|
||
}
|
||
|
||
/*
|
||
* Need to allocate new structure. Do it.
|
||
*/
|
||
if (authnumfreekeys == 0) {
|
||
if (auth_moremem() == 0)
|
||
return;
|
||
}
|
||
|
||
sk = authfreekeys;
|
||
authfreekeys = sk->next;
|
||
authnumfreekeys--;
|
||
|
||
strncpy(sk->k.MD5_key, (char *)key, sizeof(sk->k.MD5_key));
|
||
if ((sk->keylen = strlen((char *)key)) > sizeof(sk->k.MD5_key))
|
||
sk->keylen = sizeof(sk->k.MD5_key);
|
||
|
||
sk->keyid = keyno;
|
||
sk->flags = KEY_KNOWN | KEY_MD5;
|
||
sk->next = key_hash[KEYHASH(keyno)];
|
||
key_hash[KEYHASH(keyno)] = sk;
|
||
authnumkeys++;
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
/*
|
||
* auth_delkeys - delete all known keys, in preparation for rereading
|
||
* the keys file (presumably)
|
||
*/
|
||
void
|
||
auth_delkeys()
|
||
{
|
||
register struct savekey *sk;
|
||
register struct savekey **skp;
|
||
register int i;
|
||
|
||
for (i = 0; i < HASHSIZE; i++) {
|
||
skp = &(key_hash[i]);
|
||
sk = key_hash[i];
|
||
while (sk != 0) {
|
||
sk->flags &= ~(KEY_KNOWN
|
||
#ifdef MD5
|
||
| KEY_MD5
|
||
#endif
|
||
#ifdef DES
|
||
| KEY_DES
|
||
#endif
|
||
);
|
||
if (sk->flags == 0) {
|
||
*skp = sk->next;
|
||
authnumkeys--;
|
||
sk->next = authfreekeys;
|
||
authfreekeys = sk;
|
||
authnumfreekeys++;
|
||
sk = *skp;
|
||
} else {
|
||
skp = &(sk->next);
|
||
sk = sk->next;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* auth1crypt - support for two stage encryption, part 1.
|
||
*/
|
||
void
|
||
auth1crypt(keyno, pkt, length)
|
||
u_long keyno;
|
||
u_int32 *pkt;
|
||
int length; /* length of all encrypted data */
|
||
{
|
||
if (keyno && keyno != cache_keyid) {
|
||
authkeyuncached++;
|
||
if (!authhavekey(keyno)) {
|
||
authnokey++;
|
||
return;
|
||
}
|
||
}
|
||
|
||
#ifdef DES
|
||
if (!keyno || (cache_flags & KEY_DES)) {
|
||
DESauth1crypt(keyno, pkt, length);
|
||
return;
|
||
}
|
||
#endif
|
||
|
||
#ifdef MD5
|
||
if (cache_flags & KEY_MD5) {
|
||
MD5auth1crypt(keyno, pkt, length);
|
||
return;
|
||
}
|
||
#endif
|
||
}
|
||
|
||
|
||
/*
|
||
* auth1crypt - support for two stage encryption, part 1.
|
||
*/
|
||
int
|
||
auth2crypt(keyno, pkt, length)
|
||
u_long keyno;
|
||
u_int32 *pkt;
|
||
int length; /* total length of encrypted area */
|
||
{
|
||
if (keyno && keyno != cache_keyid) {
|
||
authkeyuncached++;
|
||
if (!authhavekey(keyno)) {
|
||
authnokey++;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
#ifdef DES
|
||
if (!keyno || (cache_flags & KEY_DES))
|
||
return DESauth2crypt(keyno, pkt, length);
|
||
#endif
|
||
|
||
#ifdef MD5
|
||
if (cache_flags & KEY_MD5)
|
||
return MD5auth2crypt(keyno, pkt, length);
|
||
#endif
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
authencrypt(keyno, pkt, length)
|
||
u_long keyno;
|
||
u_int32 *pkt;
|
||
int length; /* length of encrypted portion of packet */
|
||
{
|
||
int sendlength = 0;
|
||
|
||
if (keyno && keyno != cache_keyid) {
|
||
authkeyuncached++;
|
||
if (!authhavekey(keyno)) {
|
||
authnokey++;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
#ifdef DES
|
||
if (!keyno || (cache_flags & KEY_DES))
|
||
return sendlength = DESauthencrypt(keyno, pkt, length);
|
||
#endif
|
||
|
||
#ifdef MD5
|
||
if (cache_flags & KEY_MD5)
|
||
return MD5authencrypt(keyno, pkt, length);
|
||
#endif
|
||
return 0;
|
||
}
|
||
|
||
|
||
int
|
||
authdecrypt(keyno, pkt, length)
|
||
u_long keyno;
|
||
u_int32 *pkt;
|
||
int length; /* length of variable data in octets */
|
||
{
|
||
if (keyno && (keyno != cache_keyid)) {
|
||
authkeyuncached++;
|
||
if (!authhavekey(keyno)) {
|
||
authnokey++;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
#ifdef DES
|
||
if (!keyno || (cache_flags & KEY_DES))
|
||
return DESauthdecrypt(keyno, pkt, length);
|
||
#endif
|
||
|
||
#ifdef MD5
|
||
if (cache_flags & KEY_MD5)
|
||
return MD5authdecrypt(keyno, pkt, length);
|
||
#endif
|
||
|
||
return 0;
|
||
}
|