Configuração de armazenamento externo de credenciais

  • Versão de lançamento: Xanadu
  • Atualizado 1 de ago. de 2024
  • 9 min. de leitura

    • Configure a sua instância para obter credenciais de um repositório remoto.

    Esses procedimentos assumem que você já tenha um repositório externo configurado com as credenciais que deseja proteger. O identificador de credencial configurado na instância ServiceNow deve ser mapeado para a credencial real no repositório através do arquivo JAR.

    Nota:
    A ServiceNow oferece suporte a dois cofres externos por vez: um resolvedor de credencial padrão CyberArk e um resolvedor de credencial externo personalizado. Para criar um resolvedor de credencial personalizado CyberArk, ainda é necessário usar o segundo cofre externo personalizado. Além disso, nenhum cofre externo personalizado pode ser usado.

    Para configurar o Armazenamento externo de credenciais, conclua as tarefas a seguir em ordem.

    Crie um arquivo JAR para resolver credenciais

    Crie um arquivo JAR para resolver identificadores de credenciais enviados do MID Server para credenciais reais do repositório.

    Antes de Iniciar

    Função necessária: agent_admin ou admin

    Certifique-se de incluir todos os elementos de credencial que a instância espera, como a chave privada.

    Para criar um arquivo JAR para resolver as credenciais:

    Procedimento

    Use os modelos fornecidos no github ServiceNow ou no arquivo Java de amostra.
    Cuidado:
    Essas amostras são apenas um modelo. NÃO use este código em produção sem modificá-lo para o seu ambiente.
    1. Baixe os arquivos JAR de código aberto com instruções do github ServiceNow:
    2. Use o seguinte arquivo Java de amostra como modelo e modifique-o para se adequar ao seu ambiente: 
      
package com.snc.discovery;

import java.util.*;
import java.io.*;

/**
 * Basic implementation of a CredentialResolver that uses a properties file.
 */

public class CredentialResolver {

	private static String ENV_VAR = "CREDENTIAL_RESOLVER_FILE";
	private static String DEFAULT_PROP_FILE_PATH = "C:\\dummycredentials.properties";

	// These are the permissible names of arguments passed INTO the resolve()
	// method.

	// the string identifier as configured on the ServiceNow instance...
	public static final String ARG_ID = "id";

	// a dotted-form string IPv4 address (like "10.22.231.12") of the target
	// system...
	public static final String ARG_IP = "ip";

	// the string type (ssh, snmp, etc.) of credential as configured on the
	// instance...
	public static final String ARG_TYPE = "type";

	// the string MID server making the request, as configured on the
	// instance...
	public static final String ARG_MID = "mid";

	// These are the permissible names of values returned FROM the resolve()
	// method.

	// the string user name for the credential, if needed...
	public static final String VAL_USER = "user";

	// the string password for the credential, if needed...
	public static final String VAL_PSWD = "pswd";

	// the string pass phrase for the credential if needed:
	public static final String VAL_PASSPHRASE = "passphrase";

	// the string private key for the credential, if needed...
	public static final String VAL_PKEY = "pkey";

	// the string authentication protocol for the credential, if needed...
	public static final String VAL_AUTHPROTO = "authprotocol";

	// the string authentication key for the credential, if needed...
	public static final String VAL_AUTHKEY = "authkey";

	// the string privacy protocol for the credential, if needed...
	public static final String VAL_PRIVPROTO = "privprotocol";

	// the string privacy key for the credential, if needed...
	public static final String VAL_PRIVKEY = "privkey";


	private Properties fProps;

	public CredentialResolver() {
	}

	private void loadProps() {
		if(fProps == null)
			fProps = new Properties();

		try {
			String propFilePath = System.getenv(ENV_VAR);
			if(propFilePath == null) {
				System.err.println("Environment var "+ENV_VAR+" not found. Using default file: "+DEFAULT_PROP_FILE_PATH);
				propFilePath = DEFAULT_PROP_FILE_PATH;
			}

			File propFile = new File(propFilePath);
			if(!propFile.exists() || !propFile.canRead()) {
				System.err.println("Can't open "+propFile.getAbsolutePath());
			}
			else {
				InputStream propsIn = new FileInputStream(propFile);
				fProps.load(propsIn);
			}
			//fProps.load(CredentialResolver.class.getClassLoader().getResourceAsStream("dummycredentials.properties"));
		} catch (IOException e) {
			System.err.println("Problem loading credentials file:");
			e.printStackTrace();
		}
	}

	/**
	 * Resolve a credential.
	 */
	public Map resolve(Map args) {
		loadProps();
		String id = (String) args.get(ARG_ID);
		String type = (String) args.get(ARG_TYPE);
		String keyPrefix = id+"."+type+".";

		if(id.equalsIgnoreCase("misbehave"))
			throw new RuntimeException("I've been a baaaaaaaaad CredentialResolver!");

		// the resolved credential is returned in a HashMap...
		Map result = new HashMap();
		result.put(VAL_USER, fProps.get(keyPrefix + VAL_USER));
		result.put(VAL_PSWD, fProps.get(keyPrefix + VAL_PSWD));
		result.put(VAL_PKEY, fProps.get(keyPrefix + VAL_PKEY));
		result.put(VAL_PASSPHRASE, fProps.get(keyPrefix + VAL_PASSPHRASE));
		result.put(VAL_AUTHPROTO, fProps.get(keyPrefix + VAL_AUTHPROTO));
		result.put(VAL_AUTHKEY, fProps.get(keyPrefix + VAL_AUTHKEY));
		result.put(VAL_PRIVPROTO, fProps.get(keyPrefix + VAL_PRIVPROTO));
		result.put(VAL_PRIVKEY, fProps.get(keyPrefix + VAL_PRIVKEY));

		System.err.println("Error while resolving credential id/type["+id+"/"+type+"]");

		return result;
	}


	/**
	 * Return the API version supported by this class.
	 */
	public String getVersion() {
		return "1.0";
	}

	public static void main(String[] args) {
		CredentialResolver obj = new CredentialResolver();
		obj.loadProps();

		System.err.println("I spy the following credentials: ");
		for(Object key: obj.fProps.keySet()) {
			System.err.println(key+": "+obj.fProps.get(key));
		}

	}
}

    Importe um arquivo JAR para resolver credenciais

    Importe um arquivo JAR criado para resolver identificadores de credencial enviados do MID Server para credenciais reais do repositório.

    Antes de Iniciar

    Função necessária: agent_admin ou admin

    Depois de criar o arquivo JAR, importe-o na instância, onde ele se torna acessível ao MID Server.

    Procedimento

    1. Depois de criar o JAR e arquivos de propriedades, copie o arquivo de propriedades para o MID Server.
    2. Navegar até MID Server > Arquivos JAR.
    3. Clique em Nova.
    4. Preencha os seguintes campos:
      Campo Descrição
      Nome Um nome exclusivo e descritivo para identificar o arquivo na instância.
      Versão Um número de versão para o arquivo, se houver uma disponível.
      Fonte Local do arquivo JAR para fins de referência. As informações de origem não são usadas pelo sistema.
      Descrição Descrição resumida do arquivo JAR e seu propósito na instância.
    5. Clique no ícone de clipe de papel na faixa e anexe o arquivo JAR ao registro.
      Figura 1. Anexação de um arquivo JAR
      O ícone de clipe de papel aparece ao lado do botão Enviar.
    6. Clique em Enviar.
    7. Reinicie o serviço do MID Server.
      A plataforma disponibiliza o arquivo JAR para qualquer MID Server configurado para se comunicar com a instância.

    Configure o identificador de credencial

    Configure o identificador de credencial na instância.

    Antes de Iniciar

    Função necessária: administrador
    Verifique os seguintes itens:

    Procedimento

    1. Navegar até Todos > Descoberta > Credenciais ou Orquestração > Credenciais.
    2. Clique em Nova.
    3. Selecione um tipo de credencial.
    4. Marque a caixa de seleção Armazenamento de credenciais externas.
      Os campos Nome de usuário e Senha desaparecem e o campo ID de credencial e o menu Cofre de armazenamento de credencial aparecem.
    5. No menu do Cofre de armazenamento de credenciais, selecione Nenhum, o cofre CyberArk ou um cofre de armazenamento externo de credenciais personalizado.
      Nota:

      Se o cofre do CyberArk for selecionado, o menu Chave de pesquisa aparecerá com quatro opções de chave de pesquisa: "ID da credencial", "Endereço IP", "FQDN" e "Todas a opções acima". Selecionar Todas as opções acima pode prejudicar o desempenho porque requer o acesso ao cofre várias vezes.

      1. Para usar um cofre de armazenamento de credenciais externas personalizado, navegue até Configurações de cofre [vault_configuration.list] na instância.
      2. Crie um novo registro usando um nome associado a um arquivo JAR importado para um resolvedor de credenciais personalizado.

        Consulte os procedimentos Crie um arquivo JAR para resolver credenciais e Importe um arquivo JAR para resolver credenciais para obter informações sobre a criação de um cofre de armazenamento externo de credenciais personalizado.

    6. Preencha o formulário Credenciais usando os campos da seguinte tabela.
      Campo Descrição
      Nome Insira um nome exclusivo e descritivo para esta credencial.
      Ativo Habilite ou desabilite essas credenciais para uso.
      ID da Credencial Insira a chave exclusiva configurada para credenciais externas no arquivo JAR carregado no MID Server para um sistema de credenciais externas. Este é o ID passado para a classe Java no mapa de parâmetros:
      public static final String ARG_ID   = "id";
      O MID Server usa este identificador para resolver as credenciais reais no repositório.
      Nota:
      Este campo só está visível quando a caixa de seleção Armazenamento de credenciais externas está marcada.
      Marcador Permita que os criadores do fluxo de trabalho atribuam credenciais individuais a qualquer atividade em um fluxo de trabalho do Orquestração ou atribuam credenciais diferentes a cada ocorrência do mesmo tipo de atividade em um fluxo de trabalho do Orquestração.
      Armazenamento externo de credenciais Marque esta caixa de seleção para usar um sistema de armazenamento externo de credenciais externas. Quando você seleciona esta opção, os campos Nome de usuário e Senha são substituídos pelo campo ID de credencial. O Armazenamento externo de credenciais fica disponível apenas quando o plug-in Armazenamento externo de credenciais está ativado.
      Cofre de armazenamento de credenciais Escolha o cofre de Armazenamento externo de credenciais em uma lista de cofres disponíveis. O menu é composto por registros das Configurações do cofre [vault_configuration.list]. Novos registros podem ser adicionados e usar nomes associados aos arquivos JAR do resolvedor de credencial personalizado. Consulte os procedimentos Crie um arquivo JAR para resolver credenciais e Importe um arquivo JAR para resolver credenciais para obter informações sobre a criação de um cofre de armazenamento externo de credenciais personalizado.
      Aplica-se a Selecione se deseja aplicar essas credenciais a Todos os MID Servers em sua rede, ou a um ou mais MID Servers específicos. Especifique os MID Servers que devem usar essas credenciais no campo MID Servers.
      MID servers Selecione um ou mais MID Servers na lista de MID Servers disponíveis. As credenciais configuradas neste registro estão disponíveis para os MID Servers nesta lista. Este campo está disponível somente quando você seleciona MID Servers específicos no campo Aplica-se a.
      Ordem Insira a ordem (sequência) na qual a plataforma testa esta credencial ao tentar fazer login nos dispositivos. Quanto menor o número, mais alta será a exibição dessa credencial na lista. Estabeleça a ordem de credenciais ao usar um grande número de credenciais ou quando a segurança bloquear usuários após três tentativas de login com falha. Se todas as credenciais tiverem o mesmo número de ordem (ou nenhum), a Descoberta ou a Orquestração tentarão usar as credenciais em uma ordem aleatória.
    7. Clique em Enviar.

    Configure o identificador de credencial para AWS

    Configure a sua instância para obter credenciais de um repositório remoto.

    Antes de Iniciar

    Função necessária: cloud_admin

    Verifique se esses plug-ins estão ativos e se o MID Server foi instalado:
    • Descoberta [com.snc.discovery]
    • Cloud Provisioning and Governance [com.snc.cloud.mgmt]
    • Armazenamento externo de credenciais [com.snc.discovery.external_credentials]

    Por Que e Quando Desempenhar Esta Tarefa

    Esses procedimentos assumem que você já tenha um repositório externo configurado com as credenciais que deseja proteger. O identificador de credencial configurado na instância ServiceNow deve ser mapeado para a credencial real no repositório através do arquivo JAR.

    Procedimento

    1. Navegar até Todos > Descoberta > Credenciais.
    2. Selecione uma credencial suportada por seu provedor de armazenamento externo de credenciais.
    3. Preencha o formulário, usando os campos da tabela.
      Campo Descrição
      Nome Um nome exclusivo e descritivo desta credencial. Por exemplo, Amazon Web Services.
      Aplica-se a Selecione os MID Servers que podem usar essas credenciais. As opções são Todos os MID Servers ou MID Servers específicos. Se você selecionar o último, aparecerá o campo MID Servers.
      Ativo Marque a caixa para habilitar ou desabilitar a credencial.
      Conta da AWS Insira seu ID de conta AWS se suas credenciais AWS estiverem em um provedor de armazenamento externo.
      Servidores MID Selecione um ou mais MID Servers que podem usar essas credenciais.
      ID da Credencial Insira o Nome sob o qual esta credencial está armazenada no provedor de Armazenamento externo de credenciais.
      ID de credencial de privacidade Insira o nome de uma chave de privacidade SNMPv3 da CyberArk. Este campo fica visível apenas para SNMPv3 quando você selecionar a CyberArk do campo Tipo de armazenamento de credencial. Se você não estiver usando uma chave de privacidade para CyberArk, deixe este campo em branco.
      Alias de credencial Selecione um alias para esta credencial que contenha comportamentos específicos. Consulte Aliases de credencial da Descoberta para obter mais informações.
      Armazenamento externo de credenciais Marque esta caixa de seleção para usar um sistema de armazenamento externo de credenciais externas. Quando o armazenamento externo está habilitado, aparece o campo ID de credencial. Se esta caixa de seleção não estiver visível, clique no ícone de menu na barra de cabeçalho e selecione Exibição > Armazenamento externo no menu de contexto.
      Tipos de armazenamentos de credenciais Selecione CyberArk somente se estiver usando uma chave de privacidade CyberArk SNMPv3. O campo ID de credencial de privacidade aparece para permitir a entrada da chave.
    4. Clique em Enviar.