By default, the Neo4j Server is bundled with a Web server that binds to host localhost
on port 7474
, answering only requests from the local machine.
This is configured in the conf/neo4j-server.properties file:
# http port (for all data, administrative, and UI access) org.neo4j.server.webserver.port=7474 #let the webserver only listen on the specified IP. Default #is localhost (only accept local connections). Uncomment to allow #any connection. #org.neo4j.server.webserver.address=0.0.0.0
If you need to enable access from external hosts, configure the Web server in the conf/neo4j-server.properties by setting the property org.neo4j.server.webserver.address=0.0.0.0
to enable access from any host.
By default, the Neo4j Server comes with some places where arbitrary code code execution can happen. These are the Section 22.14, “Traversals” REST endpoints. To secure these, either disable them completely by removing offending plugins from the server classpath, or secure access to these URLs through proxies or Authorization Rules. Also, the Java Security Manager can be used to secure parts of the codebase.
The Neo4j server includes built in support for SSL encrypted communication over HTTPS. The first time the server starts, it automatically generates a self-signed SSL certificate and a private key. Because the certificate is self signed, it is not safe to rely on for production use, instead, you should provide your own key and certificate for the server to use.
To provide your own key and certificate, replace the generated key and certificate, or change the neo4j-server.properties file to set the location of your certificate and key:
# Certificate location (auto generated if the file does not exist) org.neo4j.server.webserver.https.cert.location=ssl/snakeoil.cert # Private key location (auto generated if the file does not exist) org.neo4j.server.webserver.https.key.location=ssl/snakeoil.key
Note that the key should be unencrypted. Make sure you set correct permissions on the private key, so that only the Neo4j server user can read/write it.
Neo4j also supports chained SSL certificates. This requires to have all certificates in PEM format combined in one file and the private key needs to be in DER format.
You can set what port the HTTPS connector should bind to in the same configuration file, as well as turn HTTPS off:
# Turn https-support on/off org.neo4j.server.webserver.https.enabled=true # https port (for all data, administrative, and UI access) org.neo4j.server.webserver.https.port=443
Administrators may require more fine-grained security policies in addition to IP-level restrictions on the Web server. Neo4j server supports administrators in allowing or disallowing access the specific aspects of the database based on credentials that users or applications provide.
To facilitate domain-specific authorization policies in Neo4j Server, SecurityRules
can be implemented and
registered with the server. This makes scenarios like user and role based security and
authentication against external lookup services possible.
In this example, a (dummy) failing security rule is registered to deny access to all URIs to the server by listing the rules class in neo4j-server.properties:
org.neo4j.server.rest.security_rules=my.rules.PermanentlyFailingSecurityRule
with the rule source code of:
public class PermanentlyFailingSecurityRule implements SecurityRule { public static final String REALM = "WallyWorld"; // as per RFC2617 :-) @Override public boolean isAuthorized( HttpServletRequest request ) { return false; // always fails - a production implementation performs // deployment-specific authorization logic here } @Override public String forUriPath() { return "/*"; } @Override public String wwwAuthenticateHeader() { return SecurityFilter.basicAuthenticationResponse(REALM); } }
With this rule registered, any access to the server will be denied. In a production-quality implementation the rule will likely lookup credentials/claims in a 3rd-party directory service (e.g. LDAP) or in a local database of authorized users.
Example request
POST
http://localhost:7474/db/data/node
Accept:
application/json; charset=UTF-8
Example response
401:
Unauthorized
WWW-Authenticate:
Basic realm="WallyWorld"
In this example, a security rule is registered to deny
access to all URIs to the server by listing the rule(s) class(es) in
neo4j-server.properties.
In this case, the rule is registered
using a wildcard URI path (where *
characters can be used to signify
any part of the path). For example /users*
means the rule
will be bound to any resources under the /users
root path. Similarly
/users*type*
will bind the rule to resources matching
URIs like /users/fred/type/premium
.
org.neo4j.server.rest.security_rules=my.rules.PermanentlyFailingSecurityRuleWithWildcardPath
with the rule source code of:
public String forUriPath() { return "/protected/*"; }
With this rule registered, any access to URIs under /protected/ will be denied by the server. Using wildcards allows flexible targeting of security rules to arbitrary parts of the server’s API, including any unmanaged extensions or managed plugins that have been registered.
Example request
GET
http://localhost:7474/protected/tree/starts/here/dummy/more/stuff
Accept:
application/json
Example response
401:
Unauthorized
WWW-Authenticate:
Basic realm="WallyWorld"
In this example, a security rule is registered to deny access to all URIs matching a complex pattern. The config looks like this:
org.neo4j.server.rest.security_rules=my.rules.PermanentlyFailingSecurityRuleWithComplexWildcardPath
with the rule source code of:
public class PermanentlyFailingSecurityRuleWithComplexWildcardPath implements SecurityRule { public static final String REALM = "WallyWorld"; // as per RFC2617 :-) @Override public boolean isAuthorized( HttpServletRequest request ) { return false; } @Override public String forUriPath() { return "/protected/*/something/else/*/final/bit"; } @Override public String wwwAuthenticateHeader() { return SecurityFilter.basicAuthenticationResponse(REALM); } }
Example request
GET
http://localhost:7474/protected/wildcard_replacement/x/y/z/something/else/more_wildcard_replacement/a/b/c/final/bit/more/stuff
Accept:
application/json
Example response
401:
Unauthorized
WWW-Authenticate:
Basic realm="WallyWorld"
Important | |
---|---|
The neo4j server exposes remote scripting functionality by default that allow full access to the underlying system. Exposing your server without implementing a security layer poses a substantial security vulnerability. |
Although the Neo4j server has a number of security features built-in (see the above chapters), for sensitive deployments it is often sensible to front against the outside world it with a proxy like Apache mod_proxy
[2].
This provides a number of advantages:
Control access to the Neo4j server to specific IP addresses, URL patterns and IP ranges. This can be used to make for instance only the /db/data namespace accessible to non-local clients, while the /db/admin URLs only respond to a specific IP address.
<Proxy *> Order Deny,Allow Deny from all Allow from 192.168.0 </Proxy>
While equivalent functionality can be implemented with Neo4j’s SecurityRule
plugins (see above), for operations professionals configuring servers like Apache is often preferable to developing plugins. However it should be noted that where both approaches are used, they will work harmoniously providing the behavior is consistent across proxy server and SecurityRule
plugins.
Run Neo4j Server as a non-root user on a Linux/Unix system on a port < 1000 (e.g. port 80) using
ProxyPass /neo4jdb/data http://localhost:7474/db/data ProxyPassReverse /neo4jdb/data http://localhost:7474/db/data
Simple load balancing in a clustered environment to load-balance read load using the Apache mod_proxy_balancer
[3] plugin
<Proxy balancer://mycluster> BalancerMember http://192.168.1.50:80 BalancerMember http://192.168.1.51:80 </Proxy> ProxyPass /test balancer://mycluster
Copyright © 2013 Neo Technology