mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![Casey Schaufler](/assets/img/avatar_default.png)
V4 updated to current linux-security#next Targeted for git://gitorious.org/smack-next/kernel.git Modern application runtime environments like to use naming schemes that are structured and generated without human intervention. Even though the Smack limit of 23 characters for a label name is perfectly rational for human use there have been complaints that the limit is a problem in environments where names are composed from a set or sources, including vendor, author, distribution channel and application name. Names like softwarehouse-pgwodehouse-coolappstore-mellowmuskrats are becoming harder to avoid. This patch introduces long label support in Smack. Labels are now limited to 255 characters instead of the old 23. The primary reason for limiting the labels to 23 characters was so they could be directly contained in CIPSO category sets. This is still done were possible, but for labels that are too large a mapping is required. This is perfectly safe for communication that stays "on the box" and doesn't require much coordination between boxes beyond what would have been required to keep label names consistent. The bulk of this patch is in smackfs, adding and updating administrative interfaces. Because existing APIs can't be changed new ones that do much the same things as old ones have been introduced. The Smack specific CIPSO data representation has been removed and replaced with the data format used by netlabel. The CIPSO header is now computed when a label is imported rather than on use. This results in improved IP performance. The smack label is now allocated separately from the containing structure, allowing for larger strings. Four new /smack interfaces have been introduced as four of the old interfaces strictly required labels be specified in fixed length arrays. The access interface is supplemented with the check interface: access "Subject Object rwxat" access2 "Subject Object rwaxt" The load interface is supplemented with the rules interface: load "Subject Object rwxat" load2 "Subject Object rwaxt" The load-self interface is supplemented with the self-rules interface: load-self "Subject Object rwxat" load-self2 "Subject Object rwaxt" The cipso interface is supplemented with the wire interface: cipso "Subject lvl cnt c1 c2 ..." cipso2 "Subject lvl cnt c1 c2 ..." The old interfaces are maintained for compatibility. Signed-off-by: Casey Schaufler <casey@schaufler-ca.com>
556 lines
14 KiB
C
556 lines
14 KiB
C
/*
|
|
* Copyright (C) 2007 Casey Schaufler <casey@schaufler-ca.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, version 2.
|
|
*
|
|
* Author:
|
|
* Casey Schaufler <casey@schaufler-ca.com>
|
|
*
|
|
*/
|
|
|
|
#include <linux/types.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/sched.h>
|
|
#include "smack.h"
|
|
|
|
struct smack_known smack_known_huh = {
|
|
.smk_known = "?",
|
|
.smk_secid = 2,
|
|
};
|
|
|
|
struct smack_known smack_known_hat = {
|
|
.smk_known = "^",
|
|
.smk_secid = 3,
|
|
};
|
|
|
|
struct smack_known smack_known_star = {
|
|
.smk_known = "*",
|
|
.smk_secid = 4,
|
|
};
|
|
|
|
struct smack_known smack_known_floor = {
|
|
.smk_known = "_",
|
|
.smk_secid = 5,
|
|
};
|
|
|
|
struct smack_known smack_known_invalid = {
|
|
.smk_known = "",
|
|
.smk_secid = 6,
|
|
};
|
|
|
|
struct smack_known smack_known_web = {
|
|
.smk_known = "@",
|
|
.smk_secid = 7,
|
|
};
|
|
|
|
LIST_HEAD(smack_known_list);
|
|
|
|
/*
|
|
* The initial value needs to be bigger than any of the
|
|
* known values above.
|
|
*/
|
|
static u32 smack_next_secid = 10;
|
|
|
|
/*
|
|
* what events do we log
|
|
* can be overwritten at run-time by /smack/logging
|
|
*/
|
|
int log_policy = SMACK_AUDIT_DENIED;
|
|
|
|
/**
|
|
* smk_access_entry - look up matching access rule
|
|
* @subject_label: a pointer to the subject's Smack label
|
|
* @object_label: a pointer to the object's Smack label
|
|
* @rule_list: the list of rules to search
|
|
*
|
|
* This function looks up the subject/object pair in the
|
|
* access rule list and returns the access mode. If no
|
|
* entry is found returns -ENOENT.
|
|
*
|
|
* NOTE:
|
|
*
|
|
* Earlier versions of this function allowed for labels that
|
|
* were not on the label list. This was done to allow for
|
|
* labels to come over the network that had never been seen
|
|
* before on this host. Unless the receiving socket has the
|
|
* star label this will always result in a failure check. The
|
|
* star labeled socket case is now handled in the networking
|
|
* hooks so there is no case where the label is not on the
|
|
* label list. Checking to see if the address of two labels
|
|
* is the same is now a reliable test.
|
|
*
|
|
* Do the object check first because that is more
|
|
* likely to differ.
|
|
*/
|
|
int smk_access_entry(char *subject_label, char *object_label,
|
|
struct list_head *rule_list)
|
|
{
|
|
int may = -ENOENT;
|
|
struct smack_rule *srp;
|
|
|
|
list_for_each_entry_rcu(srp, rule_list, list) {
|
|
if (srp->smk_object == object_label &&
|
|
srp->smk_subject == subject_label) {
|
|
may = srp->smk_access;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return may;
|
|
}
|
|
|
|
/**
|
|
* smk_access - determine if a subject has a specific access to an object
|
|
* @subject_label: a pointer to the subject's Smack label
|
|
* @object_label: a pointer to the object's Smack label
|
|
* @request: the access requested, in "MAY" format
|
|
* @a : a pointer to the audit data
|
|
*
|
|
* This function looks up the subject/object pair in the
|
|
* access rule list and returns 0 if the access is permitted,
|
|
* non zero otherwise.
|
|
*
|
|
* Smack labels are shared on smack_list
|
|
*/
|
|
int smk_access(char *subject_label, char *object_label, int request,
|
|
struct smk_audit_info *a)
|
|
{
|
|
struct smack_known *skp;
|
|
int may = MAY_NOT;
|
|
int rc = 0;
|
|
|
|
/*
|
|
* Hardcoded comparisons.
|
|
*
|
|
* A star subject can't access any object.
|
|
*/
|
|
if (subject_label == smack_known_star.smk_known) {
|
|
rc = -EACCES;
|
|
goto out_audit;
|
|
}
|
|
/*
|
|
* An internet object can be accessed by any subject.
|
|
* Tasks cannot be assigned the internet label.
|
|
* An internet subject can access any object.
|
|
*/
|
|
if (object_label == smack_known_web.smk_known ||
|
|
subject_label == smack_known_web.smk_known)
|
|
goto out_audit;
|
|
/*
|
|
* A star object can be accessed by any subject.
|
|
*/
|
|
if (object_label == smack_known_star.smk_known)
|
|
goto out_audit;
|
|
/*
|
|
* An object can be accessed in any way by a subject
|
|
* with the same label.
|
|
*/
|
|
if (subject_label == object_label)
|
|
goto out_audit;
|
|
/*
|
|
* A hat subject can read any object.
|
|
* A floor object can be read by any subject.
|
|
*/
|
|
if ((request & MAY_ANYREAD) == request) {
|
|
if (object_label == smack_known_floor.smk_known)
|
|
goto out_audit;
|
|
if (subject_label == smack_known_hat.smk_known)
|
|
goto out_audit;
|
|
}
|
|
/*
|
|
* Beyond here an explicit relationship is required.
|
|
* If the requested access is contained in the available
|
|
* access (e.g. read is included in readwrite) it's
|
|
* good. A negative response from smk_access_entry()
|
|
* indicates there is no entry for this pair.
|
|
*/
|
|
skp = smk_find_entry(subject_label);
|
|
rcu_read_lock();
|
|
may = smk_access_entry(subject_label, object_label, &skp->smk_rules);
|
|
rcu_read_unlock();
|
|
|
|
if (may > 0 && (request & may) == request)
|
|
goto out_audit;
|
|
|
|
rc = -EACCES;
|
|
out_audit:
|
|
#ifdef CONFIG_AUDIT
|
|
if (a)
|
|
smack_log(subject_label, object_label, request, rc, a);
|
|
#endif
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* smk_curacc - determine if current has a specific access to an object
|
|
* @obj_label: a pointer to the object's Smack label
|
|
* @mode: the access requested, in "MAY" format
|
|
* @a : common audit data
|
|
*
|
|
* This function checks the current subject label/object label pair
|
|
* in the access rule list and returns 0 if the access is permitted,
|
|
* non zero otherwise. It allows that current may have the capability
|
|
* to override the rules.
|
|
*/
|
|
int smk_curacc(char *obj_label, u32 mode, struct smk_audit_info *a)
|
|
{
|
|
struct task_smack *tsp = current_security();
|
|
char *sp = smk_of_task(tsp);
|
|
int may;
|
|
int rc;
|
|
|
|
/*
|
|
* Check the global rule list
|
|
*/
|
|
rc = smk_access(sp, obj_label, mode, NULL);
|
|
if (rc == 0) {
|
|
/*
|
|
* If there is an entry in the task's rule list
|
|
* it can further restrict access.
|
|
*/
|
|
may = smk_access_entry(sp, obj_label, &tsp->smk_rules);
|
|
if (may < 0)
|
|
goto out_audit;
|
|
if ((mode & may) == mode)
|
|
goto out_audit;
|
|
rc = -EACCES;
|
|
}
|
|
|
|
/*
|
|
* Return if a specific label has been designated as the
|
|
* only one that gets privilege and current does not
|
|
* have that label.
|
|
*/
|
|
if (smack_onlycap != NULL && smack_onlycap != sp)
|
|
goto out_audit;
|
|
|
|
if (capable(CAP_MAC_OVERRIDE))
|
|
rc = 0;
|
|
|
|
out_audit:
|
|
#ifdef CONFIG_AUDIT
|
|
if (a)
|
|
smack_log(sp, obj_label, mode, rc, a);
|
|
#endif
|
|
return rc;
|
|
}
|
|
|
|
#ifdef CONFIG_AUDIT
|
|
/**
|
|
* smack_str_from_perm : helper to transalate an int to a
|
|
* readable string
|
|
* @string : the string to fill
|
|
* @access : the int
|
|
*
|
|
*/
|
|
static inline void smack_str_from_perm(char *string, int access)
|
|
{
|
|
int i = 0;
|
|
if (access & MAY_READ)
|
|
string[i++] = 'r';
|
|
if (access & MAY_WRITE)
|
|
string[i++] = 'w';
|
|
if (access & MAY_EXEC)
|
|
string[i++] = 'x';
|
|
if (access & MAY_APPEND)
|
|
string[i++] = 'a';
|
|
string[i] = '\0';
|
|
}
|
|
/**
|
|
* smack_log_callback - SMACK specific information
|
|
* will be called by generic audit code
|
|
* @ab : the audit_buffer
|
|
* @a : audit_data
|
|
*
|
|
*/
|
|
static void smack_log_callback(struct audit_buffer *ab, void *a)
|
|
{
|
|
struct common_audit_data *ad = a;
|
|
struct smack_audit_data *sad = ad->smack_audit_data;
|
|
audit_log_format(ab, "lsm=SMACK fn=%s action=%s",
|
|
ad->smack_audit_data->function,
|
|
sad->result ? "denied" : "granted");
|
|
audit_log_format(ab, " subject=");
|
|
audit_log_untrustedstring(ab, sad->subject);
|
|
audit_log_format(ab, " object=");
|
|
audit_log_untrustedstring(ab, sad->object);
|
|
audit_log_format(ab, " requested=%s", sad->request);
|
|
}
|
|
|
|
/**
|
|
* smack_log - Audit the granting or denial of permissions.
|
|
* @subject_label : smack label of the requester
|
|
* @object_label : smack label of the object being accessed
|
|
* @request: requested permissions
|
|
* @result: result from smk_access
|
|
* @a: auxiliary audit data
|
|
*
|
|
* Audit the granting or denial of permissions in accordance
|
|
* with the policy.
|
|
*/
|
|
void smack_log(char *subject_label, char *object_label, int request,
|
|
int result, struct smk_audit_info *ad)
|
|
{
|
|
char request_buffer[SMK_NUM_ACCESS_TYPE + 1];
|
|
struct smack_audit_data *sad;
|
|
struct common_audit_data *a = &ad->a;
|
|
|
|
/* check if we have to log the current event */
|
|
if (result != 0 && (log_policy & SMACK_AUDIT_DENIED) == 0)
|
|
return;
|
|
if (result == 0 && (log_policy & SMACK_AUDIT_ACCEPT) == 0)
|
|
return;
|
|
|
|
sad = a->smack_audit_data;
|
|
|
|
if (sad->function == NULL)
|
|
sad->function = "unknown";
|
|
|
|
/* end preparing the audit data */
|
|
smack_str_from_perm(request_buffer, request);
|
|
sad->subject = subject_label;
|
|
sad->object = object_label;
|
|
sad->request = request_buffer;
|
|
sad->result = result;
|
|
|
|
common_lsm_audit(a, smack_log_callback, NULL);
|
|
}
|
|
#else /* #ifdef CONFIG_AUDIT */
|
|
void smack_log(char *subject_label, char *object_label, int request,
|
|
int result, struct smk_audit_info *ad)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
DEFINE_MUTEX(smack_known_lock);
|
|
|
|
/**
|
|
* smk_find_entry - find a label on the list, return the list entry
|
|
* @string: a text string that might be a Smack label
|
|
*
|
|
* Returns a pointer to the entry in the label list that
|
|
* matches the passed string.
|
|
*/
|
|
struct smack_known *smk_find_entry(const char *string)
|
|
{
|
|
struct smack_known *skp;
|
|
|
|
list_for_each_entry_rcu(skp, &smack_known_list, list) {
|
|
if (strcmp(skp->smk_known, string) == 0)
|
|
return skp;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* smk_parse_smack - parse smack label from a text string
|
|
* @string: a text string that might contain a Smack label
|
|
* @len: the maximum size, or zero if it is NULL terminated.
|
|
*
|
|
* Returns a pointer to the clean label, or NULL
|
|
*/
|
|
char *smk_parse_smack(const char *string, int len)
|
|
{
|
|
char *smack;
|
|
int i;
|
|
|
|
if (len <= 0)
|
|
len = strlen(string) + 1;
|
|
|
|
/*
|
|
* Reserve a leading '-' as an indicator that
|
|
* this isn't a label, but an option to interfaces
|
|
* including /smack/cipso and /smack/cipso2
|
|
*/
|
|
if (string[0] == '-')
|
|
return NULL;
|
|
|
|
for (i = 0; i < len; i++)
|
|
if (string[i] > '~' || string[i] <= ' ' || string[i] == '/' ||
|
|
string[i] == '"' || string[i] == '\\' || string[i] == '\'')
|
|
break;
|
|
|
|
if (i == 0 || i >= SMK_LONGLABEL)
|
|
return NULL;
|
|
|
|
smack = kzalloc(i + 1, GFP_KERNEL);
|
|
if (smack != NULL) {
|
|
strncpy(smack, string, i + 1);
|
|
smack[i] = '\0';
|
|
}
|
|
return smack;
|
|
}
|
|
|
|
/**
|
|
* smk_netlbl_mls - convert a catset to netlabel mls categories
|
|
* @catset: the Smack categories
|
|
* @sap: where to put the netlabel categories
|
|
*
|
|
* Allocates and fills attr.mls
|
|
* Returns 0 on success, error code on failure.
|
|
*/
|
|
int smk_netlbl_mls(int level, char *catset, struct netlbl_lsm_secattr *sap,
|
|
int len)
|
|
{
|
|
unsigned char *cp;
|
|
unsigned char m;
|
|
int cat;
|
|
int rc;
|
|
int byte;
|
|
|
|
sap->flags |= NETLBL_SECATTR_MLS_CAT;
|
|
sap->attr.mls.lvl = level;
|
|
sap->attr.mls.cat = netlbl_secattr_catmap_alloc(GFP_ATOMIC);
|
|
sap->attr.mls.cat->startbit = 0;
|
|
|
|
for (cat = 1, cp = catset, byte = 0; byte < len; cp++, byte++)
|
|
for (m = 0x80; m != 0; m >>= 1, cat++) {
|
|
if ((m & *cp) == 0)
|
|
continue;
|
|
rc = netlbl_secattr_catmap_setbit(sap->attr.mls.cat,
|
|
cat, GFP_ATOMIC);
|
|
if (rc < 0) {
|
|
netlbl_secattr_catmap_free(sap->attr.mls.cat);
|
|
return rc;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* smk_import_entry - import a label, return the list entry
|
|
* @string: a text string that might be a Smack label
|
|
* @len: the maximum size, or zero if it is NULL terminated.
|
|
*
|
|
* Returns a pointer to the entry in the label list that
|
|
* matches the passed string, adding it if necessary.
|
|
*/
|
|
struct smack_known *smk_import_entry(const char *string, int len)
|
|
{
|
|
struct smack_known *skp;
|
|
char *smack;
|
|
int slen;
|
|
int rc;
|
|
|
|
smack = smk_parse_smack(string, len);
|
|
if (smack == NULL)
|
|
return NULL;
|
|
|
|
mutex_lock(&smack_known_lock);
|
|
|
|
skp = smk_find_entry(smack);
|
|
if (skp != NULL)
|
|
goto freeout;
|
|
|
|
skp = kzalloc(sizeof(*skp), GFP_KERNEL);
|
|
if (skp == NULL)
|
|
goto freeout;
|
|
|
|
skp->smk_known = smack;
|
|
skp->smk_secid = smack_next_secid++;
|
|
skp->smk_netlabel.domain = skp->smk_known;
|
|
skp->smk_netlabel.flags =
|
|
NETLBL_SECATTR_DOMAIN | NETLBL_SECATTR_MLS_LVL;
|
|
/*
|
|
* If direct labeling works use it.
|
|
* Otherwise use mapped labeling.
|
|
*/
|
|
slen = strlen(smack);
|
|
if (slen < SMK_CIPSOLEN)
|
|
rc = smk_netlbl_mls(smack_cipso_direct, skp->smk_known,
|
|
&skp->smk_netlabel, slen);
|
|
else
|
|
rc = smk_netlbl_mls(smack_cipso_mapped, (char *)&skp->smk_secid,
|
|
&skp->smk_netlabel, sizeof(skp->smk_secid));
|
|
|
|
if (rc >= 0) {
|
|
INIT_LIST_HEAD(&skp->smk_rules);
|
|
mutex_init(&skp->smk_rules_lock);
|
|
/*
|
|
* Make sure that the entry is actually
|
|
* filled before putting it on the list.
|
|
*/
|
|
list_add_rcu(&skp->list, &smack_known_list);
|
|
goto unlockout;
|
|
}
|
|
/*
|
|
* smk_netlbl_mls failed.
|
|
*/
|
|
kfree(skp);
|
|
skp = NULL;
|
|
freeout:
|
|
kfree(smack);
|
|
unlockout:
|
|
mutex_unlock(&smack_known_lock);
|
|
|
|
return skp;
|
|
}
|
|
|
|
/**
|
|
* smk_import - import a smack label
|
|
* @string: a text string that might be a Smack label
|
|
* @len: the maximum size, or zero if it is NULL terminated.
|
|
*
|
|
* Returns a pointer to the label in the label list that
|
|
* matches the passed string, adding it if necessary.
|
|
*/
|
|
char *smk_import(const char *string, int len)
|
|
{
|
|
struct smack_known *skp;
|
|
|
|
/* labels cannot begin with a '-' */
|
|
if (string[0] == '-')
|
|
return NULL;
|
|
skp = smk_import_entry(string, len);
|
|
if (skp == NULL)
|
|
return NULL;
|
|
return skp->smk_known;
|
|
}
|
|
|
|
/**
|
|
* smack_from_secid - find the Smack label associated with a secid
|
|
* @secid: an integer that might be associated with a Smack label
|
|
*
|
|
* Returns a pointer to the appropriate Smack label if there is one,
|
|
* otherwise a pointer to the invalid Smack label.
|
|
*/
|
|
char *smack_from_secid(const u32 secid)
|
|
{
|
|
struct smack_known *skp;
|
|
|
|
rcu_read_lock();
|
|
list_for_each_entry_rcu(skp, &smack_known_list, list) {
|
|
if (skp->smk_secid == secid) {
|
|
rcu_read_unlock();
|
|
return skp->smk_known;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we got this far someone asked for the translation
|
|
* of a secid that is not on the list.
|
|
*/
|
|
rcu_read_unlock();
|
|
return smack_known_invalid.smk_known;
|
|
}
|
|
|
|
/**
|
|
* smack_to_secid - find the secid associated with a Smack label
|
|
* @smack: the Smack label
|
|
*
|
|
* Returns the appropriate secid if there is one,
|
|
* otherwise 0
|
|
*/
|
|
u32 smack_to_secid(const char *smack)
|
|
{
|
|
struct smack_known *skp = smk_find_entry(smack);
|
|
|
|
if (skp == NULL)
|
|
return 0;
|
|
return skp->smk_secid;
|
|
}
|