Memorizza i dati crittografati e la chiave di crittografia su diversi server MongoDB? [chiuso]

Nella mia app Rails gli utenti inviano combinazioni sensibili nome utente / password ai loro sistemi di webshop in modo che la mia app possa interagire con loro. Devo applicare un'elevata sicurezza data-resto per questi dati.

Da ciò che ho letto ad es. questa risposta alla gemma attr_encrypted è una buona soluzione per crittografare i campi del modello in MongoDB. Ma non mi piace il fatto che la funzionalità e i dati e le chiavi crittografati siano gestiti / archiviati su un singolo server. E vorrei usare una chiave univoca per ogni crittografia. Quindi sto considerando di memorizzare nomi utente su un server, password crittografate su un secondo e chiavi su un terzo.

Vedi qualche bandiera rossa in questo approccio?

Ecco come gestisco la presentazione degli utenti di un nuovo webshop:

1) Il mio server principale riceve i dati del negozio online da un utente e salva username , ma inoltra il password :

def create_webshop
  webshop = current_user.webshops.create(username: params[:username])
  HTTParty.get("https://passwords.mydomain.com/create_password?password=#{params[:password]}&webshop_id=#{webshop._id}")
end

2) Il mio server password riceve password e genera key . Quindi crittografa password e lo salva, ma inoltra il key :

def create_password
  key              = SecureRandom.base64
  password         = AESCrypt.encrypt(params[:password], key)
  password_holder  = PasswordHolder.create(webshop_id: params[:webshop_id], password: password)
  HTTParty.get("https://keys.mydomain.com/create_key?password_holder_id=#{password_holder._id}&key=#{key}")
  render :json => {}, :status => :ok
end

3) Il mio server delle chiavi riceve key e lo salva:

def create_key
  KeyHolder.create(password_holder_id: params[:password_holder_id], key: params[:key])
  render :json => {}, :status => :ok
end

Ecco come ottengo la password per un webshop:

1) Il mio server principale query per password a un dato webshop_id :

def get_password(webshop)
  password_response = HTTParty.get("https://passwords.mydomain.com/get_password?webshop_id=#{webshop._id}")
  password          = JSON.parse(password_response.body)["password"]
  # Do stuff...
end

2) Il mio server delle password riceve la query della password e le query per key a un dato password_id :

def get_password
  password_holder = PasswordHolder.where(webshop_id: params[:webshop_id]).first
  key_response    = HTTParty.get("https://keys.mydomain.com/get_key?password_holder_id=#{password_holder_id._id}")
  key             = JSON.parse(key_response.body)["key"]
  password        = AESCrypt.decrypt(password_holder.password, key)
  render :json => {:password => password}, :status => :ok
end

3) Il mio server delle chiavi riceve la query chiave e restituisce key :

def get_key
  render :json => {:key => KeyHolder.where(password_holder_id: params[:password_holder_id]).first.key}, :status => :ok
end

Il mio server password quindi decrittografa password e lo restituisce al mio server principale .