
%%%%%%%%%%%%%%%%%%%%%%% file typeinst.tex %%%%%%%%%%%%%%%%%%%%%%%%%
%
% This is the LaTeX source for the instructions to authors using
% the LaTeX document class 'llncs.cls' for contributions to
% the Lecture Notes in Computer Sciences series.
% http://www.springer.com/lncs       Springer Heidelberg 2006/05/04
%
% It may be used as a template for your own input - copy it
% to a new file with a new name and use it as the basis
% for your article.
%
% NB: the document class 'llncs' has its own and detailed documentation, see
% ftp://ftp.springer.de/data/pubftp/pub/tex/latex/llncs/latex2e/llncsdoc.pdf
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


\documentclass[runningheads,a4paper]{llncs}

\usepackage{amssymb}
\setcounter{tocdepth}{3}
\usepackage{graphicx}

\usepackage{url}
\urldef{\mailsa}\path|{jambo, presbrey}@mit.edu|
\urldef{\mailsb}\path|{timbl}@w3.org|
\newcommand{\keywords}[1]{\par\addvspace\baselineskip
\noindent\keywordname\enspace\ignorespaces#1}

\begin{document}

\mainmatter  % start of an individual contribution

% first the title is needed
\title{Using RDF Metadata To Enable Access Control on the Social Semantic Web }

% a short form should be given in case it is too long for the running head
\titlerunning{Using RDF Metadata for Access Control}

% the name(s) of the author(s) follow(s) next
%
% NB: Chinese authors should write their first names(s) in front of
% their surnames. This ensures that the names appear correctly in
% the running heads and the author index.
%
\author{James Hollenbach\and Joe Presbrey\and Tim Berners-Lee}
%
\authorrunning{Hollenbach\and Presbrey\and Berners-Lee}
% (feature abused for this document to repeat the title also on left hand pages)

% the affiliations are given next; don't give your e-mail address
% unless you accept that it will be published
\institute{Decentralized Information Group, MIT CSAIL,\\
32 Vassar Street, Cambridge, MA, USA, 02139 \\
\mailsa\\
\mailsb\\
\url{http://dig.csail.mit.edu}}

%
% NB: a more complex sample for affiliations and the mapping to the
% corresponding authors can be found in the file "llncs.dem"
% (search for the string "\mainmatter" where a contribution starts).
% "llncs.dem" accompanies the document class "llncs.cls".
%

%\toctitle{Using RDF Metadata To Enable Access Control on the Social Semantic Web}
%\tocauthor{James Hollenbach\and Joe Presbrey\and Tim Berners-Lee}
\maketitle


\begin{abstract}
The structure of the Semantic Web gives users the power to share and collaboratively 
generate decentralized linked data.  In many cases, though, 
collaboration requires some form of authentication and authorization to ensure the security and integrity of the data being generated.  Traditional authorization
systems that rely on centralized databases are insufficient in this scenario, since they rely
 on the existence of a central authority that is not available on the Semantic Web. 

In this paper, we present a scalable system that allows for decentralized user
authentication and authorization.  The system described supports per-document
access control via an RDF metadata file 
containing an access control list (ACL).  A simple interface  
allows authorized users to view and edit the RDF ACL directly in a Web browser. 
The system allows users to efficiently manage read and write
access to linked data without a centralized authority, enabling a collaborative authoring environment suited to the Semantic Web.
\keywords{Access Control, Semantic Web, FOAF+SSL, RDF, Web Access Control, Social Web, Metadata Management, Collaborative Authoring}
\end{abstract}

\section{Introduction}
In the Semantic Web community there is a growing interest in collaborative authoring of linked data.  In most collaborative environments, though, there must be an adequate authorization system in place to restrict which users can view and edit certain data.  When designing such a system for use on the Semantic Web, the following important factors must be taken into account:

\noindent
{\bf Decentralized accounts.}  On the Semantic Web, data is stored on many machines in a decentralized manner.  Requiring users to have separate accounts for each server that they edit data on would quickly become cumbersome; instead, having a single user identity would be ideal.  Additionally, such a sign-on system should not be located on a centralized server.  Instead, users should be able to maintain their own accounts on remote servers.

\noindent
{\bf Potential for rule-based authorization.} One of the greatest potential benefits of the Semantic Web is the power to reason over data provided by multiple sources.  A good system should allow administrators to create rules for authorization, such as ``Only my friends and friends of my friends can access my data''.

\noindent
{\bf Authentication speed.} Even though a decentralized authentication mechanism will by design require that information be pulled down from a remote server, the speed of the authentication itself should still be at least comparable to traditional authentication mechanisms. To achieve this, the system should ideally only need to make one request to a remote server in order to complete authentication.  Following this initial authentication, session caching should be used to prevent repeated requests to remote servers, making repeated authentication steps effectively identical in speed to traditional authentication methods.

\noindent
{\bf Ease of maintenance.} The system should allow authorized users to intuitively add and remove access for other users.  Since the access control system is intended for data shared on the Semantic Web, any ACL should also be editable from a Web browser.  This could potentially be accomplished using protocols such as WebDAV \cite{webdav} or SPARQL/Update \cite{sparul}.

The system we have implemented allows for decentralized accounts, fast authentication, and easy maintenance of ACL metadata.  Support for rule-based authorization is not currently included in favor of a simpler ACL-based implementation, but we will show that support for such reasoning could be added.  The resulting system allows users to collaboratively edit linked data stored on the Web server.

The remainder of the paper discusses our experiences in implementing and assessing our system.  In Section \ref{sec:Background}, we briefly introduce the prior work that our system is based on.  In Section \ref{sec:Server}, we describe the back-end system that allows for decentralized authentication and ACL-based authorization.  Section \ref{sec:Editor} describes the interface for viewing and editing access control files.  Finally, Sections \ref{sec:Performance}, \ref{sec:Future}, and \ref{sec:Conclusions} discuss the performance of our implementation and potential future work that would expand and improve on the present system.

\section{\label{sec:Background}Background}

In this section, we briefly discuss the prior work related to our system and how that work affected our design.

\subsection{RDF-based Access Control}

This is not the first attempt at creating an RDF-based ACL system.  Since 2002, the World Wide Web Consortium (W3C) has used an RDF-based ACL system \cite{w3acl} to control access to files on its servers.  The W3C ACL system has proven very useful for managing access to W3C files, but it has a few limitations that we aim to improve on.  First, though the actual rules granting access to a file are written in RDF, authentication and authorization are still handled by a central database.  Therefore, multiple entities trying to use the W3C ACL system would either need to share or mirror the same database for authentication.  Additionally, user information for the W3C ACL system does not necessarily identify the user with a URI.  As a result, user information in the W3C ACL database cannot easily be shared with external entities without some prior knowledge of W3C users and groups.

Despite this, the W3C ACL system provides a strong base for developing a similar system for use on the wider Semantic Web.  The major difference between the W3C ACL system and our system is the prominence of linked data and standardized protocols.  By moving all user and group data onto the Semantic Web and using a common login mechanism, we allow for access rules to be shared more readily between different organizations.
\subsection{Collaborative Authoring}

We identified two potential options for allowing collaborative authoring of files in our system: WebDAV and SPARQL/Update. Both have distinct advantages and disadvantages.  As far as support for linked data, SPARQL/Update is the clear choice: it supports insertion and deletion of small amounts of data from the target graph.  WebDAV, on the other hand, is not explicitly intended for authoring linked data documents.  Instead, when performing a WebDAV PUT, the entire document must be rewritten to the server.  If there were no other limiting factors, SPARQL/Update would be the obvious choice.  

However, due to our desire to produce a usable Apache \cite{apache} module, we had to rely on what currently exists.  As of the writing of this paper, there is no Apache module that supports SPARQL/Update.  However, WebDAV is available in the Apache module \texttt{mod\_dav}, guaranteeing widespread support.  For this reason, our current implementation uses WebDAV rather than SPARQL/Update to handle updates to the triple store and ACL metadata.  In Section \ref{sec:Future}, we discuss how the system could easily be modified to instead use SPARQL/Update when such a module becomes available.

\subsection{Decentralized Authentication}

There exist two potential methods for performing decentralized authentication: OpenID \cite{openid} and FOAF+SSL \cite{foafssl}.  While OpenID is a more established protocol, FOAF+SSL has a major advantage in that it links directly to a user's FOAF \cite{foaf} file.  The information in the user's FOAF profile (or whatever other information is stored at the URI) could potentially be used in rule-based authentication.  OpenID, on the other hand, simply provides a decentralized ID that does not necessarily have any linked data associated with it.

Briefly, the FOAF+SSL protocol works as follows: a user's public encryption key is stored in both a certificate and a remote RDF file stored on a Web server.  Additionally, the certificate is created with the URI for the location of the remote RDF file stored in the certificate's \texttt{Subject Alternative Name} field.  When a user sends a FOAF+SSL certificate to a server, the server identifies the remote URI, pulls down the public key from that URI, and compares it with the public key in the user's certificate.  If the keys match, the user is authenticated as the entity associated with the \texttt{(public key,remote URI)} pair described in the certificate.  The server can then decide whether or not to authorize a user based on a set of rules--in our case, a simple access control list.  By using self-signed certificates, FOAF+SSL provides a trust-based user network that does not rely on any central authority, which by design works perfectly in a Semantic Web environment.

\section{\label{sec:Server}Server Implementation}

\begin{figure}
\centering
\includegraphics[scale=0.225]{acl-flow}
\caption{Flowchart depicting the authentication and authorization process.  The authentication and authorization modules are implemented as Apache modules.}
\label{fig:aclflow}
\end{figure}

In this section, we describe the server-side implementation of our access control system.  The server is implemented as two Apache modules: an authentication module (\texttt{mod\_authn\_webid}) and an authorization module (\texttt{mod\_authz\_webid}).  The general flow of the authentication and authorization process is depicted in Figure \ref{fig:aclflow}.

\subsection{Authentication}
\begin{figure}
\centering
\begin{verbatim}

SELECT ?mod_hex WHERE {
    ?key rdf:type rsa:RSAPublicKey.
    ?key rsa:public_exponent ?exp.
    ?key rsa:modulus ?mod.
    ?key cert:identity ?agent.
    ?exp cert:decimal CERT_DECIMAL.
    ?mod cert:hex ?mod_hex.
}
\end{verbatim}
\caption{This SPARQL query finds all of the certificate data in the agent's remote FOAF file.  Each set of certificate data consists of an agent (user ID) and an RSA key with an exponent and modulus.}
\label{fig:sq}
\end{figure}
The authentication module implements the FOAF+SSL protocol to determine if the public keys in the user's certificate and FOAF file match.  Authentication via this module is enabled in the server's Apache configuration with the \texttt{AuthType WebID} Apache directive. To perform authentication, the module checks for a URI in the \texttt{Subject Alternative Name} field of the certificate.  Next, the certificate's signature is calculated using Apache's \texttt{mod\_ssl} \cite{modssl} module.  If this process completes successfully, the user's remote URI is dereferenced to see if it contains matching certificate data using the Redland RDF library \cite{redland}.  Finally, the SPARQL \cite{sparql} query in Figure \ref{fig:sq} is run. The query searches for all instances of a public key \texttt{?key} and its associated agent \texttt{?agent}.  If the query returns a result that matches the key and agent provided in the user's certificate, the module authenticates the user as acting on behalf of the agent and returns control back to Apache.

\subsection{Authorization}


The authorization module makes use of an N3 \cite{n3} metadata file that contains an access control list (ACL).  Metadata is currently stored on a per-directory basis, though the system could easily be modified to store ACL metadata on a per-document or even per-resource basis (see Section \ref{sec:Future}).  The server directs clients to the ACL for a given file using the \texttt{link rel=meta} HTTP header \cite{link}.  Figure \ref{fig:aclfile} shows a simple ACL used by the system.  The ACL ontology used is the Web Access Control Ontology \cite{wacl}.  For a given rule, \texttt{acl:accessTo} defines a resource that access is being granted to, \texttt{acl:agent} and \texttt{acl:agentClass} define an agent or agent class (such as ``any foaf:Person'') as being granted access, \texttt{acl:mode} defines the set of modes that are granted to the agent or agent class, and \texttt{acl:defaultForNew} optionally defines the default access rules for new documents in a directory.

\begin{figure}
\centering
\begin{verbatim}
@prefix acl: <http://www.w3.org/ns/auth/acl#> .
[]
  a acl:Authorization ;
  acl:defaultForNew <.> ;
  acl:accessTo <foaf.rdf> ;
  acl:agent <http://presbrey.mit.edu/foaf#presbrey> ;
  acl:mode acl:Control, acl:Read, acl:Write .
[]
  a acl:Authorization ;
  acl:accessTo <foaf.rdf> ;
  acl:agentClass <http://xmlns.com/foaf/0.1/Agent> ;
  acl:mode acl:Read.
\end{verbatim}
\caption{A simple ACL file.  This file grants http://presbrey.mit.edu/foaf\#presbrey Read, Write, and Control access to the file foaf.rdf, and Read access to foaf.rdf to all authenticated FOAF+SSL users. It also grants presbrey Read, Write, and Control access by default for new files.  }
\label{fig:aclfile}
\end{figure}

The three types of access that can be granted are \texttt{Read}, \texttt{Write}, and \texttt{Control}.  Each type of access is bound to a specific set of HTTP methods as described in Table \ref{tbl:acl}.  The \texttt{Read} and \texttt{Write} modes control access to normal files stored on the server.  \texttt{Control} is essentially a special form of \texttt{Write} access:  having \texttt{Control} access to a file allows a user to edit the ACL metadata for that file.  As with the authentication module, authorization is determined by running a set of SPARQL queries to determine if the user is granted access either as an agent or as a member of an agent class.  If a user attempts to use an HTTP method that they are not permitted to use, they receive a 403 response from the server.  For example, using the ACL file from Figure \ref{fig:aclfile}, if a user authenticated with the URI \texttt{http://www.example.com/foaf\#me} tried to delete \texttt{foaf.rdf} with an HTTP DELETE request, the server would see that only \texttt{presbrey} has \texttt{Write} access and respond with \texttt{403 Forbidden}.

\begin{table}[ht]
\begin{tabular}{| l | l | }
\hline
\emph{acl:mode} & \emph{HTTP Methods} \\
\hline
acl:Read & OPTIONS, GET, POST*, PROPFIND \\*

& * interpretation of POST data must also indicate Read, e.g SELECT \\
\hline
acl:Write & PUT, DELETE, PROPPATCH, MKCOL, COPY*, MOVE**\\*

& * two checks: Request URI acl:Read, Destination URI acl:Write\\*

& ** two checks: Request URI acl:Write, Destination URI acl:Write \\
\hline
acl:Control & any acl:Write to an ACL URI \\
\hline
\end{tabular}
\caption{Access control modes and their HTTP method mappings.}
\label{tbl:acl}
\end{table}

\section{\label{sec:Editor}ACL Editor  Interface}
To demonstrate the functionality of the ACL editing system, we have developed a simple Firefox extension that allows users to edit the ACL for the document they are currently viewing.  The extension is a sidebar that can be loaded alongside the current browser window.  The ACL metadata for a given document is found by looking for the aforementioned \texttt{link rel=meta} HTTP header in the server's response for a given document.  The metadata URI in the \texttt{link} header is dereferenced, and the ACL is displayed to the user as a list of agents and agent classes (See Figure \ref{fig:acleditor}).

Authorized users are able to modify the ACL directly in this interface by manipulating a series of checkboxes.  New agents can be added, and current agents can be removed.  When a user attempts to submit new ACL data, the interface serializes the state of the interface into a new ACL file.  This modified file is then submitted to the server via a WebDAV PUT.  Concurrent ACL modifications are prevented optimistically using the HTTP \texttt{ETag} header.  Successful changes to the ACL take effect immediately.

\begin{figure}
\centering
\includegraphics[scale=0.5]{acl-both}
\caption{Viewing the ACL metadata from Figure \ref{fig:aclfile} in the ACL Editor.  On the left, the file is unmodified.  On the right, the highlighted bottom row indicates the user has added the agent http://web.mit.edu/jambo/www/foaf.rdf\#jambo, but not yet submitted the changes.}
\label{fig:acleditor}
\end{figure}
\section{\label{sec:Performance}Performance}


Though the FOAF+SSL authentication mechanism requires that the server make a request for a remote resource in order to perform authentication, it would be ideal for our system to nevertheless achieve performance comparable with traditional authentication mechanisms.  To that end, we have performed performance tests in order to compare our authentication mechanism with traditional Apache authentication methods.  The tests were run using ApacheBench, included with Apache, on an Apache instance running in single-process mode on a Quad-Core AMD Opteron 2350 2GHz Xen VM guest with 512MB of RAM.  ApacheBench performed 1000 serial requests for a null document in each configuration.  The four test configurations used tested the time needed for Apache to complete authentication requests depending on whether or not a certificate is presented and whether or not our authentication module is enabled. Table \ref{tbl:perf} shows the average performance of each configuration over the course of five test runs.

\begin{table}[ht]
\begin{tabular}{| l | l | }
\hline
\emph{Apache Test Configuration} & \emph{Request Time (ms/request)} \\
\hline
without client certificate, without mod\_authn\_webid & 4.2 \\
\hline
without client certificate, with mod\_authn\_webid & 4.43 \\
\hline
with WebID client certificate, without mod\_authn\_webid & 4.63 \\
\hline
with WebID client certificate, with mod\_authn\_webid & 11.31 \\
\hline
\end{tabular}
\caption{Benchmark results for mod\_authn\_webid.}
\label{tbl:perf}
\end{table}

The results clearly show that the module takes a few milliseconds to request the remote resource containing a user's certificate information.  In this case, the request time is relatively short, since the two machines were sitting quite close to each other.  With the addition of a WebID cache, though, the need for repeated requests for remote resources has been removed--a cached version of the agent's data is used instead for the duration of a session.  In many cases, the inital request will not have very high latency, as in this example.  But even in those cases where an initial request takes some time, subsequent requests will run at a speed comparable to normal certificate-based authentication, since the remote request is not repeated.

\section{\label{sec:Future}Future Work}

With our first WebID- and Linked Data-based authorization system, we have created a highly functional codebase allowing for collaborative editing of Semantic Web documents.  In this section, we describe a list of potential future enhancements that would greatly increase the ease with which users could edit data.

\subsection{Packaging With SPARQL/Update-Ready Systems}

Our current implementation uses WebDAV to allow for collaborative editing.  However, this is by no means a requirement of the system.  Over time, more systems are coming into existence that support SPARQL/Update for editing documents in an Apache environment, such as ARC2 \cite{arc2} and the Tabulator Data Wiki \cite{tabr}.  These systems could be layered above our existing framework, with our framework limiting the HTTP methods a client can use (and, by extension, the sort of operations that a user can perform on a triple store).  By switching over to SPARQL/Update, the size of updates sent by clients will be much smaller and have a lower potential for error, since clients will no longer be required to parse and serialize an entire document just to insert a single triple into the ACL data or triple store.

\subsection{Per-Resource Access Control}

While we currently provide access control at the document level, RDF is often stored as multiple resources described in a single flat file or in a triple store that does not even have a notion of specific documents.  The current system is not able to restrict access on a per-resource basis unless resources are each stored in their own file.  Such a system would require more complex analysis of an incoming update or query to determine exactly which resources are being read and written.  While this feature is not included at present, it is worth noting that the ACL system used here could be modified to accommodate access defined on a per-resource basis.  The first step in implementing such a system would probably be to have an engine capable of analyzing SPARQL/Update queries to decide which resources they affect.

Of course, one of the most difficult parts of adding per-resource access control is identifying exactly what it means for a read or write operation to ``affect'' a resource.  A simple engine could designate a read or write operation as pertaining to a certain resource if the operation traverses or modifies an arc coming out of that resource.  In this case, adding a ``has\_child'' property to a parent would be considered a write modification to the parent, but not its new child.  Some examples, however, can have greater consequences for a given resource.  For example, if a user has write access to a class definition $C$, but is not granted write access to one of $C$'s subclasses, the user could still greatly alter (or even break) the semantics of that subclass by simply modifying $C$.  The importance of this issue will vary between use cases--for someone maintaining an open social network, the first method may be more appropriate; but for someone editing ontologies, maintaining consistency will be key.

\subsection{Rule-based Access Control}

This project uses a very simple form of access control--a simple whitelist contained in a metadata file.  However, some users might want to define dynamic rules like the ``friend-of-a-friend'' rule described in the introduction.  While such rules are certainly more descriptive than a whitelist, designing an interface that allows users to quickly modify rules and add new agents as our ACL Editor does is much more difficult.  On the back-end, however, one would simply need to hook into a rule engine immediately prior to authorizing a user.  At this point, our system exposes a user's URI and the query that the user is trying to run.  This information could easily be plugged into an external reasoner to decide if the user is permitted to perform a given action or log the user's actions for later analysis. It should also be noted that using complex rules to regulate access to resources in a triple store could greatly affect the speed of the authentication process, since a proof would need to be constructed instead of searching for the appropriate triple indicating access.

\section{\label{sec:Conclusions}Conclusion}

The system described provides a solid base for future projects implementing Web Access Control and collaborative authoring of linked data.  It provides an implementation of an RDF-based decentralized authentication protocol, namely FOAF+SSL.  Authentication speeds, keeping in mind the need for an initial remote request, are comparable with traditional authentication systems.  Users can quickly and easily add access for new agents without having to manually edit a metadata file.

That such a system can be implemented on a traditional Web server like Apache shows that there is potential for widespread adoption of accountable collaborative editing of linked data.  The layout of this system allows for applications, linked data, and user agent authentication to all be stored on separate servers maintained by completely independent entities.  By plugging services such as policy-aware query processors and data access logs into our system, one could create a complete policy-aware system based in an entirely decentralized environment, realizing the full potential of the Semantic Web.

\subsubsection*{Acknowledgments} Thanks go to the members and students of DIG
and the W3C who provided excellent knowledge and feedback throughout the course
of this project.  This work was supported by IARPA Award \#FA8750-07-2-0031 and National Science Foundation Cybertrust Grant award CT-M: 0831442.

\begin{thebibliography}{4}

%\bibitem{jour} Smith, T.F., Waterman, M.S.: Identification of Common Molecular
%Subsequences. J. Mol. Biol. 147, 195--197 (1981)

%\bibitem{lncschap} May, P., Ehrlich, H.C., Steinke, T.: ZIB Structure Prediction Pipeline:
%Composing a Complex Biological Workflow through Web Services. In: Nagel,
%W.E., Walter, W.V., Lehner, W. (eds.) Euro-Par 2006. LNCS, vol. 4128,
%pp. 1148--1158. Springer, Heidelberg (2006)

%\bibitem{book} Foster, I., Kesselman, C.: The Grid: Blueprint for a New Computing
%Infrastructure. Morgan Kaufmann, San Francisco (1999)

%\bibitem{proceeding1} Czajkowski, K., Fitzgerald, S., Foster, I., Kesselman, C.: Grid
%Information Services for Distributed Resource Sharing. In: 10th IEEE
%International Symposium on High Performance Distributed Computing, pp.
%181--184. IEEE Press, New York (2001)

%\bibitem{proceeding2} Foster, I., Kesselman, C., Nick, J., Tuecke, S.: The Physiology of the
%Grid: an Open Grid Services Architecture for Distributed Systems
%Integration. Technical report, Global Grid Forum (2002)

%\bibitem{url} National Center for Biotechnology Information, \url{http://www.ncbi.nlm.nih.gov}

\bibitem{webdav} RFC 4918 - HTTP Extensions for Web Distributed Authoring and Versioning (WebDAV), \url{http://tools.ietf.org/html/rfc4918}

\bibitem{sparul} SPARQL Update, \url{http://www.w3.org/Submission/SPARQL-Update/}

\bibitem{w3acl} W3C ACL System, \url{http://www.w3.org/2001/04/20-ACLs}

\bibitem{apache} The Apache Software Foundation, \url{http://www.apache.org/}

\bibitem{openid} Recordon, D., Reed, D.: OpenID 2.0: a platform for user-centric identity management. In: Proceedings of the Second ACM Workshop on Digital Identity Management, pp. 11--16. ACM, New York (2006)

\bibitem{foafssl} Story, H., Harbulot, B., Jacobi, I., Jones, M.: FOAF+SSL: RESTful Authentication for the Social Web. In: European Semantic Web Conference, Workshop: SPOT2009. Heraklion, Greece (2009)

\bibitem{foaf} FOAF Vocabulary Specification, \url{http://xmlns.com/foaf/spec/}

\bibitem{modssl} mod\_ssl: The Apache Interface to OpenSSL, \url{http://www.modssl.org/}

\bibitem{redland} Redland RDF Libraries, \url{http://librdf.org/}

\bibitem{sparql} SPARQL Query Language for RDF, \url{http://www.w3.org/TR/rdf-sparql-query/}

\bibitem{n3} Notation3 (N3) A Readable RDF Syntax, \url{http://www.w3.org/DesignIssues/Notation3}

\bibitem{link} An Entity Header for Linked Resources, \url{http://www.w3.org/Protocols/9707-link-header.html}

\bibitem{wacl} Basic Access Control Ontology, \url{http://www.w3.org/ns/auth/acl#}

\bibitem{arc2} Easy RDF and SPARQL for LAMP Systems, \url{http://arc.semsol.org/}

\bibitem{tabr} Berners-Lee, T., Hollenbach, J., Lu, K., Presbrey, J., Prud'hommeaux, E., schraefel, mc.: Tabulator Redux: Browsing and writing linked data. In: WWW 2008, Workshop: Linked Data on the Web (LDOW 2008) (2008). 
\end{thebibliography}

\section*{Appendix: Source Code}
The source code for this project is available at the following locations:

\noindent
Authentication Module: \url{http://dig.csail.mit.edu/2009/mod_authn_webid/}

\noindent
Authorization Module: \url{http://dig.csail.mit.edu/2009/mod_authz_webid/}

\noindent
ACL Editor: \url{http://dig.csail.mit.edu/2009/aclsidebar/}


\end{document}
