| /******************************************************************************* |
| * Copyright (c) 2007, 2008 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.osgi.internal.service.security; |
| |
| import java.io.*; |
| import java.security.cert.CertificateException; |
| import java.util.Properties; |
| import org.eclipse.core.runtime.adaptor.LocationManager; |
| import org.eclipse.osgi.baseadaptor.BaseData; |
| import org.eclipse.osgi.framework.internal.core.AbstractBundle; |
| import org.eclipse.osgi.framework.internal.core.FrameworkProperties; |
| import org.eclipse.osgi.framework.log.FrameworkLogEntry; |
| import org.eclipse.osgi.internal.baseadaptor.DevClassPathHelper; |
| import org.eclipse.osgi.internal.provisional.service.security.*; |
| import org.eclipse.osgi.internal.signedcontent.SignedBundleHook; |
| import org.eclipse.osgi.internal.signedcontent.SignedStorageHook; |
| import org.eclipse.osgi.service.resolver.*; |
| import org.eclipse.osgi.signedcontent.SignedContent; |
| import org.eclipse.osgi.signedcontent.SignerInfo; |
| import org.osgi.framework.*; |
| |
| public class DefaultAuthorizationEngine extends AuthorizationEngine { |
| |
| private static final String VERSION_PROP = "Version"; //$NON-NLS-1$ |
| private static final String VERSION_NUM = "1.0"; //$NON-NLS-1$ |
| private static final Version VERSION_MAX = new Version(2, 0, 0); |
| |
| private final State systemState; |
| private final BundleContext bundleContext; |
| |
| public static final int ENFORCE_NONE = 0x0000; |
| public static final int ENFORCE_SIGNED = 0x0001; |
| public static final int ENFORCE_TRUSTED = 0x0002; |
| public static final int ENFORCE_VALIDITY = 0x0004; |
| |
| private static final String STR_ENFORCE_NONE = "any"; //$NON-NLS-1$ |
| private static final String STR_ENFORCE_SIGNED = "signed"; //$NON-NLS-1$ |
| private static final String STR_ENFORCE_TRUSTED = "trusted"; //$NON-NLS-1$ |
| private static final String STR_ENFORCE_VALIDITY = "validity"; //$NON-NLS-1$ |
| |
| private static final String POLICY_NAME = "org.eclipse.equinox.security"; //$NON-NLS-1$ |
| private static final String POLICY_PROP = "osgi.signedcontent.authorization.engine.policy"; //$NON-NLS-1$ |
| private static final String FILE_LOAD_POLICY = ".loadpolicy"; //$NON-NLS-1$ |
| private static int enforceFlags = 0; |
| |
| private static final File policyFile; |
| static { |
| File osgiFile = LocationManager.getOSGiConfigurationDir(); |
| policyFile = new File(osgiFile.getPath() + File.separatorChar + FILE_LOAD_POLICY); |
| |
| Properties properties = null; |
| // load the policy file, if not exist, create it and load it |
| if (policyFile.exists()) { |
| try { |
| properties = new Properties(); |
| properties.load(new FileInputStream(policyFile)); |
| } catch (IOException e) { |
| SignedBundleHook.log("Error loading policy file", FrameworkLogEntry.ERROR, e); //$NON-NLS-1$ |
| } |
| } |
| |
| if (properties != null) { |
| Version version = new Version(0, 0, 0); |
| String versionProp = properties.getProperty(VERSION_PROP); |
| if (versionProp != null) |
| try { |
| version = new Version(versionProp); |
| } catch (IllegalArgumentException e) { |
| // do nothing; |
| } |
| if (VERSION_MAX.compareTo(version) > 0) { |
| String policy = properties.getProperty(POLICY_PROP); |
| if (policy != null) |
| try { |
| enforceFlags = Integer.parseInt(policy); |
| } catch (NumberFormatException e) { |
| // do nothing; |
| } |
| } |
| } else { |
| String policy = FrameworkProperties.getProperty(POLICY_PROP); |
| if (policy == null || STR_ENFORCE_NONE.equals(policy)) |
| enforceFlags = ENFORCE_NONE; |
| else if (STR_ENFORCE_TRUSTED.equals(policy)) |
| enforceFlags = ENFORCE_TRUSTED | ENFORCE_SIGNED; |
| else if (STR_ENFORCE_SIGNED.equals(policy)) |
| enforceFlags = ENFORCE_SIGNED; |
| else if (STR_ENFORCE_VALIDITY.equals(policy)) |
| enforceFlags = ENFORCE_TRUSTED | ENFORCE_SIGNED | ENFORCE_VALIDITY; |
| } |
| |
| } |
| |
| public DefaultAuthorizationEngine(BundleContext context, State systemState) { |
| super(context); |
| this.bundleContext = context; |
| this.systemState = systemState; |
| } |
| |
| protected AuthorizationEvent doAuthorize(SignedContent content, Object context) { |
| boolean enabled = isEnabled(content, context); |
| AuthorizationEvent event = null; |
| if (context instanceof Bundle) { |
| BundleDescription desc = systemState.getBundle(((Bundle) context).getBundleId()); |
| if (!enabled) { |
| DisabledInfo info = new DisabledInfo(POLICY_NAME, null, desc); // TODO add an error message |
| systemState.addDisabledInfo(info); |
| event = new AuthorizationEvent(AuthorizationEvent.DENIED, content, context, 0); // TODO severity?? |
| } else { |
| DisabledInfo info = systemState.getDisabledInfo(desc, POLICY_NAME); |
| if (info != null) { |
| systemState.removeDisabledInfo(info); |
| } |
| event = new AuthorizationEvent(AuthorizationEvent.ALLOWED, content, context, 0); |
| } |
| } |
| return event; |
| } |
| |
| private boolean isEnabled(SignedContent content, Object context) { |
| if (context instanceof Bundle && DevClassPathHelper.inDevelopmentMode()) { |
| String[] devClassPath = DevClassPathHelper.getDevClassPath(((Bundle) context).getSymbolicName()); |
| if (devClassPath != null && devClassPath.length > 0) |
| return true; // always enabled bundles from workspace; they never are signed |
| } |
| if ((0 != (enforceFlags & ENFORCE_SIGNED)) && ((content == null) || !content.isSigned())) |
| return false; |
| |
| SignerInfo[] signerInfos = content == null ? new SignerInfo[0] : content.getSignerInfos(); |
| for (int i = 0; i < signerInfos.length; i++) { |
| if ((0 != (enforceFlags & ENFORCE_TRUSTED)) && !signerInfos[i].isTrusted()) |
| return false; |
| if ((0 != (enforceFlags & ENFORCE_VALIDITY))) |
| try { |
| content.checkValidity(signerInfos[i]); |
| } catch (CertificateException e) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| public int getStatus() { |
| if (0 != systemState.getDisabledBundles().length) { |
| return AuthorizationStatus.ERROR; |
| } |
| return AuthorizationStatus.OK; |
| } |
| |
| public void processInstalledBundles() { |
| Bundle[] bundles = bundleContext.getBundles(); |
| for (int i = 0; i < bundles.length; i++) { |
| BaseData baseData = (BaseData) ((AbstractBundle) bundles[i]).getBundleData(); |
| SignedStorageHook hook = (SignedStorageHook) baseData.getStorageHook(SignedStorageHook.KEY); |
| SignedContent signedContent = hook != null ? hook.getSignedContent() : null; |
| authorize(signedContent, bundles[i]); |
| } |
| } |
| |
| public void setLoadPolicy(int policy) { |
| if ((policy | ENFORCE_SIGNED | ENFORCE_TRUSTED | ENFORCE_VALIDITY) != (ENFORCE_SIGNED | ENFORCE_TRUSTED | ENFORCE_VALIDITY)) |
| throw new IllegalArgumentException("Invalid policy: " + policy); //$NON-NLS-1$ |
| enforceFlags = policy; |
| Properties properties = new Properties(); |
| properties.setProperty(POLICY_PROP, Integer.toString(policy)); |
| properties.setProperty(VERSION_PROP, VERSION_NUM); // need to act different when we have different versions |
| try { |
| properties.store(new FileOutputStream(policyFile), null); |
| } catch (IOException e) { |
| SignedBundleHook.log("Error saving load policy file", FrameworkLogEntry.ERROR, e); //$NON-NLS-1$ |
| } |
| } |
| |
| public int getLoadPolicy() { |
| return enforceFlags; |
| } |
| |
| } |