I have to implement a solution to share some xml files between a frontend server in a DMZ and his backend in an internal network. Both servers are Solaris 10 boxes. What is the better way regarding security?

The backend server has a oracle database and both servers creates xml files. So, I have two process: 1. When the frontend server generates the xml file, the backend server takes it and loads it to the database 2. When the backend creates an xml file, the frontend server, through a java servlet, reads that xml file and deletes it.

Basically, this application needs a pool where let and take the xml files and that could be accessible by both servers.

  • Does the backend server need to be in the trust? – k to the z May 23 '13 at 15:28
  • 1
    Hi Julian - as it stands this is not a good question here. There may be circumstances where either may be the right answer, so better is not a useful term. Please read the guidance on the faq pages on how to ask your question in such a way that it can be answered. Give more context. Descibe the environment etc. – Rory Alsop May 23 '13 at 15:28
  • 1
    (personally though, I'd avoid nfs... just sayin') – Rory Alsop May 23 '13 at 15:29
  • 1
    I agree with @RoryAlsop, this question is a bit vague. If you could specify what better means for you (in a practical, contextual sense) and maybe provide a meaningful context to your question so we can understand what's being asked here better, that would be great. If your question gets closed in the meantime, feel free to edit it to fit better with our website and it'll be automatically added to the reopen review queue. Thanks! – TildalWave May 23 '13 at 15:47
  • 3
    SNEAKER NET. Don't open hole into your internal network. – Jason H May 23 '13 at 16:43

When you state "share" I am envisioning an xml file that is written on one server (backend), given to the other (frontend) where someone can read, download it. Did you mean a specific file that is shared (written, opened) by both symmetrically?

E.g.: you have an application that needs to apply xml values for a visitor:

Webserver --> Display content (use this shared XML file) --> Internet visitor

In this example, the XML is static, won't change, can be viewed by any, and all via the frontend connection. Never needs to be addressed/modified by developers.

Developer <--> Backend (modify XML) <--> Server (read/give this xml file in realtime) <--> Frontend --> Internet visitor

In the second example, makes sense if this xml file is frequently edited. If you choose to use NFS, I would choose sNFS (NFS over SSH) and make sure that ONLY those two servers can talk to each other via sNFS (firewall). If not, if someone compromises the frontend, they have an avenue into the backend (NFS).

In the initial example, suppose the xml file is modified infrequently, in that set up, you can use something like a quick socat/scp transfer from the frontend, to ensure there is no mechanism for an attacker to pivot via NFS to the backend.


Neither a shared filesystem nor SSH satisfy the Principle of Least Privilege, so neither is "secure" solution.

Instead, the best way is to set up an access mechanism that grants file access to the specified files (and no others) to a properly-credentialed request. Those credentials should ONLY be useful for obtaining the necessary files.

A simple example would be a web server (over HTTPS if necessary) running on the server that has the files, but which only allows access to the server that is supposed to be able to retrieve them, and which only does so after the appropriate password is supplied. HTTP authentication and a couple of Allow/Deny rules would be sufficient.

This way the level of access granted couldn't be usable in escalating privileges or accessing different computers, and the information is reasonably secure with respect to others on the network that don't need it.

Not the answer you're looking for? Browse other questions tagged or ask your own question.