1/* 2 * Copyright (c) 2000-2010,2012-2013 Apple Inc. All Rights Reserved. 3 * 4 * @APPLE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. Please obtain a copy of the License at 10 * http://www.opensource.apple.com/apsl/ and read it before using this 11 * file. 12 * 13 * The Original Code and all software distributed under the License are 14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 18 * Please see the License for the specific language governing rights and 19 * limitations under the License. 20 * 21 * @APPLE_LICENSE_HEADER_END@ 22 */ 23 24 25// 26// session - authentication session domains 27// 28#ifndef _H_SESSION 29#define _H_SESSION 30 31#include "structure.h" 32#include "acls.h" 33#include "authority.h" 34#include "authhost.h" 35#include <Security/AuthSession.h> 36#include <security_utilities/ccaudit.h> 37#include <security_cdsa_utilities/handletemplates_defs.h> 38#include <security_cdsa_utilities/u32handleobject.h> 39#include <security_cdsa_utilities/cssmdb.h> 40#include <bsm/audit.h> 41#include <bsm/audit_session.h> 42#include <sys/event.h> 43#include "securityd_service/securityd_service/securityd_service_client.h" 44 45class Key; 46class Connection; 47class Server; 48class AuthHostInstance; 49 50enum { 51 session_keybag_locked = 0, 52 session_keybag_unlocked = 1 << 0, 53 session_keybag_check_master_key = 1 << 1, 54 session_keybag_loaded = 1 << 2, 55}; 56 57// 58// A Session object represents one or more Connections that are known to 59// belong to the same authentication domain. Informally this means just 60// about "the same user", for the right definition of "user." The upshot 61// is that global credentials can be shared by Connections of one Session 62// with a modicum of security, and so Sessions are the natural nexus of 63// single-sign-on functionality. 64// 65class Session : public PerSession { 66public: 67 typedef au_asid_t SessionId; // internal session identifier (audit session id) 68 69 Session(const CommonCriteria::AuditInfo &audit, Server &server); 70 virtual ~Session(); 71 72 Server &server() const; 73 74 SessionId sessionId() const { return mAudit.sessionId(); } 75 CommonCriteria::AuditInfo &auditInfo() { return mAudit; } 76 77 IFDUMP(virtual void dumpNode()); 78 79public: 80 static const SessionAttributeBits settableAttributes = 81 sessionHasGraphicAccess | sessionHasTTY | sessionIsRemote | AU_SESSION_FLAG_HAS_AUTHENTICATED; 82 83 SessionAttributeBits attributes() const { updateAudit(); return mAudit.ai_flags; } 84 bool attribute(SessionAttributeBits bits) const { return attributes() & bits; } 85 void setAttributes(SessionAttributeBits bits); 86 87 virtual void setupAttributes(SessionCreationFlags flags, SessionAttributeBits attrs); 88 89 virtual uid_t originatorUid(); 90 91 virtual CFDataRef copyUserPrefs() = 0; 92 93 static const char kUsername[]; 94 static const char kRealname[]; 95 96public: 97 const CredentialSet &authCredentials() const { return mSessionCreds; } 98 99 // 100 // For external Authorization clients 101 // 102 OSStatus authCreate(const AuthItemSet &rights, const AuthItemSet &environment, 103 AuthorizationFlags flags, AuthorizationBlob &newHandle, const audit_token_t &auditToken); 104 void authFree(const AuthorizationBlob &auth, AuthorizationFlags flags); 105 static OSStatus authGetRights(const AuthorizationBlob &auth, 106 const AuthItemSet &requestedRights, const AuthItemSet &environment, 107 AuthorizationFlags flags, AuthItemSet &grantedRights); 108 OSStatus authGetInfo(const AuthorizationBlob &auth, const char *tag, AuthItemSet &contextInfo); 109 110 OSStatus authExternalize(const AuthorizationBlob &auth, AuthorizationExternalForm &extForm); 111 OSStatus authInternalize(const AuthorizationExternalForm &extForm, AuthorizationBlob &auth); 112 113 OSStatus authorizationdbGet(AuthorizationString inRightName, CFDictionaryRef *rightDict); 114 OSStatus authorizationdbSet(const AuthorizationBlob &authBlob, AuthorizationString inRightName, CFDictionaryRef rightDict); 115 OSStatus authorizationdbRemove(const AuthorizationBlob &authBlob, AuthorizationString inRightName); 116 117 // 118 // Authorization methods for securityd's internal use 119 // 120 OSStatus authCheckRight(string &rightName, Connection &connection, bool allowUI); 121 // authCheckRight() with exception-handling and Boolean return semantics 122 bool isRightAuthorized(string &rightName, Connection &connection, bool allowUI); 123 124protected: 125 void updateAudit() const; 126 127private: 128 struct AuthorizationExternalBlob { 129 AuthorizationBlob blob; 130 uint32_t session; 131 }; 132 133protected: 134 static AuthorizationToken &authorization(const AuthorizationBlob &blob); 135 OSStatus authGetRights(AuthorizationToken &auth, 136 const AuthItemSet &requestedRights, const AuthItemSet &environment, 137 AuthorizationFlags flags, AuthItemSet &grantedRights); 138 void mergeCredentials(CredentialSet &creds); 139 140public: 141 void invalidateSessionAuthHosts(); // invalidate auth hosts in this session 142 static void invalidateAuthHosts(); // invalidate auth hosts in all sessions 143 144 static void processSystemSleep(); 145 void processLockAll(); 146 147 RefPointer<AuthHostInstance> authhost(const AuthHostType hostType = securityAgent, const bool restart = false); 148 149protected: 150 mutable CommonCriteria::AuditInfo mAudit; 151 152 mutable Mutex mCredsLock; // lock for mSessionCreds 153 CredentialSet mSessionCreds; // shared session authorization credentials 154 155 mutable Mutex mAuthHostLock; 156 AuthHostInstance *mSecurityAgent; 157 AuthHostInstance *mAuthHost; 158 159 CFRef<CFDataRef> mSessionAgentPrefs; 160 Credential mOriginatorCredential; 161 162 void kill(); 163 164public: 165 void verifyKeyStorePassphrase(int32_t retries); 166 void changeKeyStorePassphrase(); 167 void resetKeyStorePassphrase(const CssmData &passphrase); 168 service_context_t get_current_service_context(); 169 void keybagClearState(int state); 170 void keybagSetState(int state); 171 bool keybagGetState(int state); 172private: 173 int mKeybagState; 174 175public: 176 static Session &find(SessionId id, bool create); // find and optionally create 177 template <class SessionType> static SessionType &find(SecuritySessionId id); 178 static void destroy(SessionId id); 179 180protected: 181 typedef std::map<SessionId, RefPointer<Session> > SessionMap; 182 static SessionMap mSessions; 183 static Mutex mSessionLock; 184}; 185 186 187template <class SessionType> 188SessionType &Session::find(SecuritySessionId id) 189{ 190 if (SessionType *ssn = dynamic_cast<SessionType *>(&find(id, false))) 191 return *ssn; 192 else 193 MacOSError::throwMe(errSessionInvalidId); 194} 195 196 197// 198// The RootSession is the session of all code that originates from system startup processing 199// and does not belong to any particular login origin. (Or, if you prefer, whose login origin 200// is the system itself.) 201// 202class RootSession : public Session { 203public: 204 RootSession(uint64_t attributes, Server &server); 205 206 CFDataRef copyUserPrefs() { return NULL; } 207}; 208 209 210// 211// A DynamicSession object represents a session that is dynamically constructed 212// when we first encounter it. These sessions are actually created in client 213// space using the audit session APIs. 214// We tear down a DynamicSession when the system reports (via kevents) that the 215// kernel audit session object has been destroyed. 216// 217class DynamicSession : private ReceivePort, public Session { 218public: 219 DynamicSession(const CommonCriteria::AuditInfo &audit); 220 221 void setUserPrefs(CFDataRef userPrefsDict); 222 CFDataRef copyUserPrefs(); 223}; 224 225 226#endif //_H_SESSION 227