¿Estrategia para mantener la información secreta, como las claves API, fuera del control de la fuente?

Estoy trabajando en un sitio web que permitirá a los usuarios iniciar sesión con credenciales de OAuth de Twitter, Google, etc. Para hacer esto, tengo que registrarme con estos diversos proveedores y obtener una clave API súper secreta que tengo para proteger con promesas contra diversas partes del cuerpo. Si mi llave se engancha, la parte se arranca.

La clave API tiene que viajar con mi fuente, ya que se usa en tiempo de ejecución para realizar solicitudes de autenticación. En mi caso, la clave debe existir dentro de la aplicación en un archivo de configuración o dentro del propio código. Eso no es un problema cuando construyo y publico desde una sola máquina. Sin embargo, cuando agregamos el control de la fuente a la mezcla, las cosas se vuelven más complicadas.

Como soy un bastardo barato, preferiría usar servicios de control de fuente gratuitos como TFS en la nube o GitHub. Esto me deja con un ligero enigma:

¿Cómo puedo mantener mi cuerpo intacto cuando mis claves API están en mi código y mi código está disponible en un repositorio público?

Se me ocurren varias formas de manejar esto, pero ninguna de ellas es tan satisfactoria.

• Podría eliminar toda la información privada del código y volver a editarla después de la implementación. Implementar esto sería un dolor severo (no detallaré las muchas formas), y no es una opción.
• Podría encriptarlo. Pero como tengo que descifrarlo, cualquiera con la fuente podría descubrir cómo hacerlo. Inútil.
• Podría pagar por el control de fuentes privadas. LOL j / k gastar dinero? Por favor.
• Podría usar las funciones del lenguaje para segregar información confidencial del resto de mi fuente y, por lo tanto, mantenerla fuera del control de la fuente. Esto es lo que estoy haciendo ahora, pero podría arruinarse fácilmente al registrar erróneamente el archivo secreto.

Realmente estoy buscando una forma garantizada de garantizar que no comparta mis partes privadas con el mundo (excepto en Snapchat) que funcione sin problemas durante el desarrollo, la depuración y la implementación, y que también sea infalible. Esto es completamente poco realista. Entonces, ¿qué puedo hacer de manera realista?

_{Detalles técnicos: VS2012, C # 4.5, el control de origen será el servicio TF o GitHub. Actualmente utiliza una clase parcial para dividir las claves confidenciales en un archivo .cs separado que no se agregará al control de origen. Creo que GitHub puede tener la ventaja ya que .gitignore podría usarse para garantizar que el archivo de clase parcial no esté registrado, pero lo he estropeado antes. Espero un "oh, problema común, así es como lo haces", pero es posible que tenga que conformarme con "eso no apesta tanto como podría haber",: /}

No ponga su información secreta en su código. Póngalo en un archivo de configuración que su código lea al inicio. Los archivos de configuración no deben colocarse en el control de versiones, a menos que sean los "valores predeterminados de fábrica", y luego no deben tener ninguna información privada.

Consulte también la pregunta Control de versiones y archivo de configuración personal para saber cómo hacerlo bien.

Puede poner todas las claves privadas / protegidas como variables de entorno del sistema. Su archivo de configuración se verá así:

private.key=#{systemEnvironment['PRIVATE_KEY']}

Así es como manejamos esos casos y nada entra en el código. Funciona muy bien combinado con diferentes archivos de propiedades y perfiles. Utilizamos diferentes archivos de propiedades para diferentes entornos. En nuestro entorno de desarrollo local, colocamos las claves de desarrollo en los archivos de propiedades para simplificar la configuración local:

private.key=A_DEVELOPMENT_LONG_KEY

Pura manera Git

• .gitignore archivo incluido con datos privados
• Use una sucursal local, en la que reemplace TEMPLATEconDATA
• Utilice filtros de borrones / limpieza, en los que el script del filtro (local) realiza el reemplazo bidireccional TEMPLATE<->DATA

Camino mercurial

• MQ-patch (es) encima del código ficticio, que se reemplaza TEMPLATEcon DATA(los conjuntos de cambios son públicos, el parche es privado)
• Extensión de palabras clave con palabras clave especialmente diseñadas (expandidas solo en su directorio de trabajo )

Manera agnóstica de SCM

• Reemplazar palabras clave como parte del proceso de compilación / implementación

Pongo secretos en los archivos encriptados que luego confirmo. La frase de contraseña se proporciona cuando se inicia el sistema, o se almacena en un archivo pequeño que no confirmo. Es bueno que Emacs gestione alegremente estos archivos cifrados. Por ejemplo, el archivo de inicio de emacs incluye: (cargar "secrets.el.gpg"), que simplemente funciona, solicitándome la contraseña en esas raras ocasiones cuando inicio el editor. No me preocupa que alguien rompa el cifrado.

Esto es muy específico de Android / Gradle, pero podría definir las claves en su gradle.propertiesarchivo global ubicado en user home/.gradle/. Esto también es útil, ya que puede utilizar diferentes propiedades según buildType o flavour, es decir, API para desarrolladores y diferentes para el lanzamiento.

gradle.properties

MY_PRIVATE_API_KEY=12356abcefg

build.gradle

buildTypes {
        debug{
            buildConfigField("String", "GOOGLE_VERIFICATION_API_KEY", "\"" + MY_PRIVATE_API_KEY +"\"")
            minifyEnabled false
            applicationIdSuffix ".debug"
            }
        }

En el código que haría referencia como este

String myAPI = BuildConfig.GOOGLE_VERIFICATION_API_KEY;

Se supone que no debe distribuir esa clave con su aplicación o almacenarla en el repositorio de código fuente. Esta pregunta es cómo hacer eso, y eso no es lo que normalmente se hace.

Aplicación web móvil

Para Android / iPhone, el dispositivo debe solicitar la CLAVE de su propio servicio web cuando la aplicación se ejecuta por primera vez. La clave se almacena en un lugar seguro. En caso de que el editor cambie o revoque la clave. Su servicio web puede publicar una nueva clave.

Aplicación web alojada

Los clientes que usen una licencia de su software deberán ingresar la clave manualmente cuando configuren el software por primera vez. Puede darles a todos la misma clave, diferentes claves o ellos obtienen la suya.

Código fuente publicado

Usted almacena su código fuente en un repositorio público pero no la CLAVE. En la configuración del archivo, agregue las líneas * coloque la tecla aquí * . Cuando un desarrollador usa su código fuente, hace una copia del sample.cfgarchivo y agrega su propia clave.

No mantiene su config.cfgarchivo utilizado para desarrollo o producción en el repositorio.

Utilice variables de entorno para cosas secretas que cambian para cada servidor.

http://en.wikipedia.org/wiki/Environment_variable

Cómo usarlos depende del idioma.

Creo que este es un problema con el que todos han tenido problemas en algún momento.

Aquí hay un flujo de trabajo que he usado, que podría funcionar para usted. Utiliza .gitignore con un toque:

1. Todos los archivos de configuración van en una carpeta especial (con archivos de configuración de muestra - opcional)
2. Todos los archivos de configuración están incluidos en .gitignore, para que no se hagan públicos
3. Configure un servidor gitolite (o su servidor git favorito) en una caja privada
4. Agregue un repositorio con todos los archivos de configuración en el servidor privado
5. Agregue un script para copiar archivos de configuración a la carpeta especial en el repositorio principal (opcional)

Ahora, puede clonar el repositorio de configuración en cualquier sistema de desarrollo e implementación. Simplemente ejecute el script para copiar los archivos en la carpeta correcta y listo.

Todavía obtienes todos los dulces de GitHub, comparte tu código con el mundo y los datos confidenciales nunca están en el repositorio principal, por lo que no se hacen públicos. Todavía están a solo un tirón y una copia de cualquier sistema de implementación.

Utilizo una caja de 15 $ / año para el servidor privado de git, pero también puedes configurar uno en casa, según el requisito de tacaño ;-)

PD: También puedes usar un submódulo git ( http://git-scm.com/docs/git-submodule ), pero siempre olvido los comandos, ¡reglas tan rápidas y sucias!

Utilice el cifrado, pero proporcione una clave maestra al inicio, como una contraseña en la consola, en un archivo que solo el usuario del proceso pueda leer, o de un almacén de claves proporcionado por el sistema como el llavero Mac OS o el almacén de claves de Windows.

Para una entrega continua, querrá varias claves grabadas en algún lugar. La configuración debe estar delimitada del código, pero tiene mucho sentido mantenerla bajo control de revisión.

3 estrategias, aún no mencionadas (?)

En el check in o en un VCS pre-check in hook

• buscar cadenas con alta entropía, por ejemplo, detectar secretos
• Regex busca patrones de clave API bien conocidos. Las claves AKIA * de AWS son un ejemplo, git-secrets es una herramienta basada en eso. Además, nombres de variables como 'contraseña' con asignación constante.
• busca secretos conocidos: conoces tus secretos, busca texto en ellos. O use una herramienta, escribí esta prueba de concepto .

Estrategias ya mencionadas

• almacenar en un archivo fuera del árbol de origen
• tenerlo en el árbol fuente, pero dile a VCS que lo ignore
• Las variables de entorno son una variación en el almacenamiento de datos fuera del árbol de origen
• simplemente no les des los valiosos secretos a los desarrolladores

Mantenga la información privada fuera de su control de origen. Cree un valor predeterminado no cargado para distribución y haga que su VCS ignore el real. Su proceso de instalación (ya sea manual, configurar / construir o asistente) debe manejar la creación y el llenado del nuevo archivo. Opcionalmente, modifique los permisos en el archivo para garantizar que solo el usuario requerido (¿servidor web?) Pueda leerlo.

Beneficios:

• No asume entidad de desarrollo == entidad de producción
• No asume que todos los colaboradores / revisores de código son confiables
• Evite errores fáciles manteniéndolo fuera del control de versiones
• Instalaciones fáciles de automatizar con configuración personalizada para control de calidad / compilaciones

Si ya está haciendo esto y lo está registrando accidentalmente, agréguelo a su proyecto .gitignore. Esto hará que sea imposible volver a hacerlo.

No son un montón de servidores gratuitos Git alrededor que proporcionan repositorios privados. Aunque nunca debe versionar sus credenciales, puede ser barato y tener repositorios privados también. ^ _ ^

En lugar de tener la clave OAuth almacenada como datos sin procesar en cualquier lugar, ¿por qué no ejecutar la cadena a través de algún algoritmo de cifrado y almacenarla como un hash salado? Luego use un archivo de configuración para restaurarlo en tiempo de ejecución. De esa forma, la clave no se almacena en ningún lado, ya sea en un cuadro de desarrollo o en el servidor mismo.

Incluso podría crear una API de modo que su servidor genere automáticamente una nueva clave API salada y hash por solicitud, de esa manera ni siquiera su equipo puede ver la fuente de OAuth.

Editar: Quizás pruebe la Biblioteca criptográfica Javascript de Stanford , ya que permite un cifrado / descifrado simétrico bastante seguro.