openvpn no puede importar configuraciones en la nueva instalación 14.04

Editar: lo arregló en ese entonces cuando se implementó el parche con agregar configuración VPN. Ya no uso Linux / Ubuntu ahora.

Instalé el OpenVPN Network-Manager haciendo:, sudo apt-get install network-manager-openvpnque también instala el paquete gnome.

Esto hizo posible importar configuraciones bajo 13.10, pero en mi nueva instalación, puedo señalar los .confarchivos, pero después de hacer clic en importar, el administrador simplemente desaparece y no se agrega ninguna conexión.

Intenté configurarlo manualmente, lo que funcionó, pero mi conexión sigue cayendo después de un tiempo, supongo porque no configuré manualmente hasta el último detalle de la configuración muy detallada.

Conectando a través del terminal haciendo: sudo openvpn --config /path/to/openvpn.confme pidió un nombre de usuario, luego una contraseña, pero luego no se conecta.

¿Qué puedo hacer para arreglar esto? Realmente necesito mi VPN, cualquier ayuda es muy apreciada.

Editar: Es un error / 1294899

Para la cola de reapertura: alguien tiene una muy buena solución para esto y usó una edición para poner esto, pero esto es digno de su propia respuesta: votar para reabrir ...

Tienes razón, es un error del administrador de red. Pero yo (y tú también) podemos evitarlo ejecutando openvpn desde la línea de comandos. Probablemente haya realizado al menos algunos de estos pasos, pero por si acaso (y en beneficio de otros) lo haré paso a paso.

Primero instale los paquetes requeridos

sudo apt-get install network-manager network-manager-openvpn network-manager-openvpn-gnome

Crear archivos Estos archivos deben mantenerse seguros y privados en todo momento

1. Cree un directorio llamado openvpn en su directorio de inicio Copie su archivo de cliente VPN (renombrado client.ovpn) en el directorio openvpn
2. Opcional: conserve una copia original del archivo; llámelo client.ovpn.orig
3. A continuación, crearemos 4 archivos en el directorio openvpn.
4. Consulte la parte inferior de este archivo para ver cómo automatizar los siguientes pasos
5. Abra el archivo client.ovpn en un editor de texto.
6. Cree un archivo llamado ca.crt: copie el texto entre <ca>y </ca>desde client.ovpn en este archivo
7. Cree un archivo llamado client.crt: copie el texto entre <cert>y </cert>desde client.ovpn en este archivo
8. Cree un archivo llamado client.key: copie el texto entre <key>y </key>desde client.ovpn en este archivo
9. Cree un archivo llamado ta.key: copie el texto entre <tls-auth>y </tls-auth>desde client.ovpn en este archivo. En este momento, tengo un total de 6 archivos en mi directorio openvpn (incluido el archivo de respaldo)

5-9 Acabo de descubrir cómo hacer bash script. Whoop Copie lo siguiente en un archivo de texto:

#!/bin/bash
sed '1,/<ca>/d;/<\/ca>/,$d' client.ovpn > ca.crt
sed '1,/<cert>/d;/<\/cert>/,$d' client.ovpn > client.crt
sed '1,/<key>/d;/<\/key>/,$d' client.ovpn > client.key
sed '1,/<tls-auth>/d;/<\/tls-auth>/,$d' client.ovpn > ta.key

Guarde el archivo como openvpnconvert en la carpeta openvpn junto con el archivo client.ovpn. Hecho ejecutable con el comando chmod a + x:

chmod a+x openvpnconvert

Y luego lo ejecutó:

./openvpnconvert

Modificar el archivo client.ovpn

Justo antes de la línea ## —– COMIENCE LA FIRMA RSA—– agregue las líneas a continuación y guarde

ca ca.crt
cert client.crt
key client.key
tls-auth ta.key

Finalmente, debe ejecutar openvpn desde la interfaz de línea de comandos (CLI)

cd en la carpeta openvpn

cd openvpn

Ejecute openvpn, si está usando los nombres de archivo que especifiqué, vea a continuación, de lo contrario use sus nombres de archivo.

sudo openvpn --client --config ~/openvpn/client.ovpn --ca ~/openvpn/ca.crt

Actualmente estoy ejecutando OpenVPN, que configuré utilizando exactamente estos pasos. Espero que funcione igual de bien para los demás.

Fuentes:

Creación de archivos: http://naveensnayak.wordpress.com/2013/03/04/ubuntu-openvpn-with-ovpn-file/

Ejecutando desde la línea de comandos - http://ubuntuforums.org/showthread.php?t=2206811

Pensé que faltaba la opción, pero simplemente se movió. Elija agregar conexión primero, luego, en lugar de elegir OpenVPN (como estaba haciendo), desplácese hacia abajo y elija la última opción "importar una VPN guardada ..."

encontré la respuesta aquí: http://torguard.net/knowledgebase.php?action=displayarticle&id=53

Nunca intenté importar estos datos de conexión, pero he usado lo siguiente en diferentes ocasiones:

• coloque el archivo whatever.confjunto con las .crtcredenciales /etc/openvpne inicie / detenga la conexión VPN consudo service openvpn whatever start|stop

• cree la conexión VPN a través del NetworkManager ingresando los datos de conexión manualmente. El archivo de configuración para la conexión se colocará en /etc/NetworkManager/system-connectionsy se puede editar más tarde.

Script de extracción:

En respuesta a la útil respuesta de Tamsyn Michael, hice un pequeño programa para automatizar la tarea de extracción. Produce los archivos apropiados necesarios para openvpn y luego agrega estos nombres de archivo al archivo de configuración original.

//woahguy@askubuntu

#include <iostream>
#include <string.h>
#include <stdio.h>

using namespace std;

int i = 0;

string buffer, filename, ca, cert, key, auth;

struct _tags { const char* first; const char* last; };

const char* files[] = { "ca.crt", "client.crt", "client.key", "ta.key" };

_tags tags[] = {
    { "<ca>", "</ca>" },
    { "<cert>", "</cert>" },
    { "<key>", "</key>" },
    { "<tls-auth>", "</tls-auth>" }
};

string string_between( string str, const string& from, const string& to ) {
    size_t first = str.find(from);
    size_t last = str.find(to);
    return( str.substr ( first+from.size(),last-first-to.size()));
}

int read_file_to_buffer( string filename )
{
    char line[12];
    FILE* pFile = fopen( filename.c_str(), "r" );
    if( pFile != NULL ) {
        while( fgets( line, sizeof( line ), pFile ) ) {
            buffer.append( line );
        }
    } else {
        return 1;
    }
    return 0;
}

int write_buffer_to_file( string buffer, string filename )
{
    FILE* pFile = fopen( filename.c_str(), "w" );
    if( pFile != NULL ) {
        fwrite (buffer.c_str(), sizeof(char), buffer.size(), pFile);
        fclose(pFile);
    } else {
        return 1;
    }
    return 0;
}

int append_found_tags_to_main( int type )
{
    FILE* pFile = fopen( filename.c_str(), "a+" );
    if( pFile != NULL ) {
        if( type == 1 ) {
            fprintf( pFile, "\nca %s\r\ncert %s\r\nkey %s\r\n",
                files[0], files[1], files[2] );
        } else {
            fprintf( pFile, "\nca %s\r\ncert %s\r\nkey %s\r\ntls-auth %s\r\n",
                files[0], files[1], files[2], files[3] );
        }
        fclose(pFile);
    }
    return 0;
}

int extract_tags( )
{
    while (buffer.find(tags[i].first) != std::string::npos ) {
        if( i == 0 ) {
            ca = string_between( buffer, tags[i].first, tags[i].last);
        } else if( i == 1 ) {
            cert = string_between( buffer, tags[i].first, tags[i].last);
        } else if( i == 2 ) {
            key = string_between( buffer, tags[i].first, tags[i].last);
        } else if( i == 3 ) {
            auth = string_between( buffer, tags[i].first, tags[i].last);
        } else {
            return 1;
        }
        i++;
    }
    return 0;
}

int write_tags( )
{
    if( !ca.empty() && !cert.empty() && !key.empty() ) {
        write_buffer_to_file( ca, files[0] );
        write_buffer_to_file( cert, files[1] );
        write_buffer_to_file( key, files[2] );
        if( !auth.empty() ) {
            write_buffer_to_file( auth, files[3] );
            append_found_tags_to_main( 0 );
        } else {
            append_found_tags_to_main( 1 );
            return 1;
        }
    } else {
        return 2;
    }
}

int main(int argc, char* argv[])
{
    if( argv[1] == NULL ) {
        printf("certgrabber<: You need to specify a valid filename to extract from.\r\n");
        return 1;
    } else {
        if( argv[2] != NULL && argv[3] != NULL && argv[4] != NULL && argv[5] != NULL) {
            files[0] = argv[2];
            files[1] = argv[3];
            files[2] = argv[4];
            files[2] = argv[5];
        }
        filename = argv[1];
    }
    read_file_to_buffer( argv[1] );
    if( buffer.empty()){
        printf("certgrabber<: You need to specify a valid filename to extract from.\r\n");
        return 2;
    }
    if( extract_tags() == 0 ) {
        int result = write_tags();
        if( result == 0 ) {
            printf("certgrabber<: All certificates and keys successfully extracted.\r\n");
        } else if( result == 1 ) {
            printf("certgrabber<: Unable to find a TLS auth key, but this isn't exactly an error.\r\n");
        } else if( result == 2 ) {
            printf("certgrabber<: Something went totally wrong with the certificate files.\r\n");
        }
    } else {
        printf("certgrabber<: Something went wrong while extracting the tags.\r\n");
        return 3;
    }
    return 0;
}

Compilación y construcción:

Necesitará instalar g ++ para construir esto

sudo apt-get install g++

Luego desde la terminal

g++ -c main.cpp -o main.o \ g++ -o certgrabber main.o 

Ahora tendrá el programa 'certgrabber' en la carpeta.

Uso del programa:

Extraer a los nombres de archivo predeterminados (ca.crt, client.crt, client.key, tls-auth.key)

./certgrabber settings.ovpn

Extraer a nombres de archivo personalizados

./certgrabber settings.ovpn ca-1.crt client-1.crt client-1.key tls-1.key

El problema con AGREGAR una VPN desde un archivo .ovpn guardado todavía falla.

Es posible AGREGAR uno manualmente.

1. Seleccione Indicador de aplicación NM, -> VPN -> Configurar VPN -> Agregar -> OpenVPN
2. Nombra manualmente tu conexión e ingresa la dirección IP de tu servidor
3. Seleccione el tipo de autenticación: para mí es Contraseña + Certificados
4. Ingrese su nombre de usuario y contraseña
5. Seleccione sus certificados y claves para los siguientes tres cuadros.
6. Seleccione Avanzado desde abajo

7. Ingrese el PUERTO (en el archivo .ovpn, generalmente en la parte inferior después de la dirección IP en la posición "XX":

   remoto ###. ###. ##. ## XX

8. Si su VPN es TCP, marque la casilla "Usar una conexión TCP"

9. Seleccione Aceptar y luego Guardar.

En este punto, la conexión VPN debería figurar en NM AppIndicator como una opción. Selecciona y prueba tu conexión. Pude agregar un tipo de conexión TCP y UDP, pero me costó mucho más de lo que hubiera hecho si el archivo guardado .ovpn de importación funcionara.

Esperemos que solucionen esto pronto para que pueda agregar fácilmente otra conexión ... pero al menos esta es una solución que debería ayudar a las personas frustradas como yo.

He creado un script aquí para automatizar contraseña de ir a buscar y comprimir archivos de varios sitios VPN, como vpnbook.com , extrayendo las ca, certy keylos datos de los archivos OVPN, y la actualización de los archivos OPVN por lo que los certs sólo debe importar para usted. Se podría modificar fácilmente para usar con otros proveedores.