Foro - Perl en Español

por **hugo11ab** » 2016-11-07 21:03 @919

¿Qué tal? Buen día a todos.

Aquí nuevamente pidiéndoles sus apreciados consejos. Me están solicitando el desarrollo de un sistema en ambiente web que esté desarrollado en Perl y que contenga seguridad.

Anteriormente he desarrollado aplicaciones en ambiente web y todo era a base de tablas y utilizaba los siguientes módulos:

use CGI qw/:standard :html3/;
use DBI;
use CGI::Carp('fatalsToBrowser');
use CGI param,header,p;
use CGI::Session;
use HTML::Table;
use Time::localtime;
use DateTime;
use Number::Format qw(:subs);
use MIME::Base64;
use warnings;

Actualmente, ¿qué módulos podría utilizar para desarrollar el sistema antes mencionado en ambiente web donde pueda separar código Perl del HTML, utilizar HTML5, sesiones, implementar seguridad al sistema...

De antemano, muchas gracias.

Puedes seguir usando lo mismo, pero se aconseja que todo código HTML vaya aparte, con algún sistema de plantillas, como Template Toolkit o Mason. Yo algunas veces usaba HTML::Template, ya que necesitaba hacer algo sencillo.

Para aumentar la seguridad en este tipo de entornos, lo mejor y más rápido es activar el modo Taint de Perl. En la primera línea del programa, donde está puesto el shebang, agregas '-T'. Algo así:

#!/usr/bin/perl -T

y el programa funcionará con el modo de "entintado" activado: no te dejará acceder de forma sencilla a los datos que te entregue el usuario, por lo que estarás obligado a "extraer" o "filtrar" la información que esperas del usuario, por medio de alguna expresión regular, por ejemplo.

Tienes más información en tu ordenador con el comando perldoc perlsec (en inglés).

Desde hace unos años, la comunidad está jubilando todos los módulos CGI, y se aconseja que este tipo de programas se desarrollen bajo el estándar PGSI.

Tienes una explicación muy buena en el documento CGI::Alternatives.

por **explorer** » 2016-11-09 18:00 @791

Añado otro punto de vista.

También ayuda bastante la utilización de un entorno de trabajo ("framework") web, como Catalyst, Dancer, Mojolicious o CGI::Application.

Catalyst es completo, pero algo feo.

Dancer es muy moderno, pero con muchas dependencias.

Mojolicious tiene un montón de utilerías modernas, pero es muy grande ya que no quiere dependencias (que es otra ventaja), pero a veces rompe con la versión anterior.

CGI::Application es el entorno de trabajo web clásico. Quizás se ha quedado algo anticuado... pero también tiene su propia web

Si has estado trabajando con CGI y CGI::Session, CGI::Application es la evolución natural, ya que les engloba, pero hace años que no se actualiza.

Titanium es otro entorno de trabajo web, basado en CGI::Application.

Yo, por mí, escogería Mojolicious.

por **hugo11ab** » 2016-11-09 21:36 @942

Gracias, explorer. Empezaré a ver la información.

por **explorer** » 2016-11-10 08:32 @397

Por aquí tenemos un tutorial de Catalyst.

por **memrobles** » 2017-05-05 13:45 @615

Hola, buenas compañeros.

Si la comunidad está dejando de usar CGI, ¿cómo hacemos ahora para el login de usuarios web?

Actualmente uso algo como esto, solo que lo conecte a MySQL:
(de hecho, es tu código, explorer

)

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
        #
        # Ejemplo de CGI::Session para login
        #
        use strict;
        use warnings;
        use diagnostics;
         
        use CGI::Session;
        use CGI ':standard';
        use CGI::Carp qw'fatalsToBrowser warningsToBrowser';
         
         
        ## Creamos el objeto CGI
        my $cgi = CGI->new();  
         
        ## Creamos el objeto CGI::Session
        my $session = CGI::Session->new("driver:File", $cgi, {'Directory'=>'/tmp/'})
            or die CGI::Session->errstr;
         
        ## Enviamos la cookie de sesión al usuario
        print $session->header;
         
        # Aquí guardaremos el perfil del usuario
        my $perfil;
         
        ## Inicialización
        if ( not $session->param('~registrado') ) {     # si el usuario no está registrado
         
            # vemos si se está registrando en este momento
            if (my $nombre = $cgi->param('login_nombre')) {
                my $passwd = $cgi->param('login_passwd');  
         
                # Vemos si es un usuario conocido por nosotros
                # si lo es, obtenemos su perfil
                if ($perfil = usuario_registrado($nombre, $passwd)) {
                   
                    # Guardamos el perfil asociado a la sesión
                    $session->param('perfil', $perfil);
                    $session->param('~registrado', 1);
                }
                else {  # Es un desconocido, le pedimos que rellene el registro otra vez
                    presenta_login('Usuario desconocido');
                    exit;
                }
            }
            else {      # No está registrado ni se está registrando
               presenta_login('Identifíquese');
               exit;
            }
        }
        else {          # es un usuario registrado (hay una sesión de él)
            # recuperamos el perfil, desde la sesión
            $perfil = $session->param('perfil');
        }
         
         
        # A partir de aquí, sabemos qué usuario es, y su perfil
        # Podemos presentarle las opciones propias de un usuario registrado
        my $nombre = $perfil->{nombre};         # otra forma de hacerlo sería recuperar esta información
        my $email  = $perfil->{email};          # desde la base de datos, ya que sabemos qué usuario es
         
        if ($cgi->param('Desconectar')) {       # caso de que el usuario quiera desconectarse
            $session->clear(['~registrado']);   # olvidamos que estaba registrado
         
            print       # despedida
                start_html('Desconexión'),
                h1('Desconexión'),
                hr(),
                p("Adios, $nombre"),
                end_html()
                ;
        }
        else {          # una página normal
            print
                start_html('Bienvenido'),
                h1('Bienvenido'),
                hr(),
                p("Bienvenido $nombre ($email)"),
                hr(),
                p(a({-href=>'ficheros.html'},'Ver lista de ficheros')),
                p(a({-href=>$cgi->url() . '?Desconectar=1'},'Desconectar')),
                end_html()
                ;
        }
         
        # Perfil de un determinado usuario
        sub usuario_registrado {
            my ($nombre, $passwd) = @_;
         
            # aquí consultaríamos una base de datos, por ejemplo
            if ($nombre eq 'JF'  and  $passwd eq '2010') {
                # si es un usuario en nuestra base de datos, recuperamos su perfil
                return { nombre => $nombre, email => '[email protected]' };
            }
             
            return;
        }
         
        # Presenta el formulario de entrada
        sub presenta_login {
            my $titulo = shift;
         
            print
                start_html,
                h1('Registro de entrada: ' . $titulo),
                start_form,
                p('Nombre: '     . textfield('login_nombre')),
                p('Contraseña: ' . password_field('login_passwd','',8,8)),
                p(),
                submit('Entrar'),
                end_form,
                end_html()
                ;
        }
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

por **memrobles** » 2017-05-05 14:05 @628

Bueno, investigando un poco encontré algo http://blogs.perl.org/users/joel_berger/2012/10/a-simple-mojoliciousdbi-example.html

Seguiré investigando, disculpad mi ignorancia :oops:

por **explorer** » 2017-05-05 15:41 @695

Para Mojolicious hay un complemento: Mojolicious::Plugin::Authentication

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

use Mojolicious::Plugin::Authentication
 
$self->plugin('authentication' => {
    'autoload_user' => 1,
    'session_key' => 'wickedapp',
    'load_user' => sub { ... },
    'validate_user' => sub { ... },
    'current_user_fn' => 'user', # compatibility with old code
});
 
if ($self->authenticate('username', 'password', { optional => 'extra data stuff' })) {
    ...
}
 
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Esta es la forma más cómodo. Otra opción es usar el método under() para indicar qué rutas se deben ejecutar bajo una misma comprobación (verificar que el usuario se ha autenticado).

Otra forma de hacerlo, también más incómoda.

por **memrobles** » 2017-05-05 18:03 @794

Gracias, explorer.

Mira, encontré esto.

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
 
use Mojolicious::Lite;
use Mojolicious::Plugin::Authentication;
use Mojolicious::Plugin::Bcrypt;
use Mojolicious::Plugin::Database;
use DBI;
 
#
# The auth database contains the user accounts
#
# Sample schema:
# CREATE TABLE user (user_id integer primary key, 
#                    user_name varchar,
#                    user_passwd varchar);
#
# The user_passwd fields contains a bcrypt hash
#
 
plugin 'database' => {
    dsn      => 'dbi:SQLite:dbname=auth',
    username => q{},
    password => q{},
    options  => { RaiseError => 1 },
    helper   => 'db',
 
};
 
#
# Use strong encryption
#
 
plugin 'bcrypt';
 
#
# Database-based authentication example
#
 
plugin 'authentication' => {
 
    load_user => sub {
 
        my ( $self, $uid ) = @_;
 
        my $sth = $self->db->prepare(' select * from user where user_id=? ');
 
        $sth->execute($uid);
 
        if ( my $res = $sth->fetchrow_hashref ) {
 
            return $res;
 
        }
        else {
 
            return;
        }
 
    },
 
    validate_user => sub {
 
        my ( $self, $username, $password ) = @_;
 
        my $sth
            = $self->db->prepare(' select * from user where user_name = ? ');
 
        $sth->execute($username);
 
        return unless $sth;
 
        if ( my $res = $sth->fetchrow_hashref ) {
 
            my $salt = substr $password, 0, 2;
 
            if ( $self->bcrypt_validate( $password, $res->{user_passwd} ) ) {
 
                $self->session(user => $username);
 
                #
                # For data that should only be visible on the next request, like
                # a confirmation message after a 302 redirect, you can use the
                # flash.
                #
                
                $self->flash(message => 'Thanks for logging in.');
 
                return $res->{user_id};
 
            }
            else {
 
                return;
 
            }
 
        }
        else {
 
            return;
 
        }
    },
 
};
 
#
# This page is visible only to authenticated users
#
 
any '/welcome' => sub {
 
    my $self = shift;
 
    if ( not $self->user_exists ) {
 
        $self->flash( message => 'You must log in to view this page' );
 
        $self->redirect_to('/');
 
        return;
 
    }
    else {
 
        $self->render( template => 'welcome' );
 
    }
 
};
 
#
# Try to log in the user
#
 
any '/login' => sub {
 
    my $self = shift;
 
    my $user = $self->param('name') || q{};
 
    my $pass = $self->param('pass') || q{};
 
    if ( $self->authenticate( $user, $pass ) ) {
 
        $self->redirect_to('/welcome');
 
    }
    else {
 
        $self->flash( message => 'Invalid credentials!' );
 
        $self->redirect_to('/');
 
    }
 
};
 
#
# Close the session
#
 
any '/logout' => sub {
 
    my $self = shift;
 
    $self->session( expires => 1 );
 
    $self->redirect_to('/');
 
};
 
#
# If logged in, show the welcome page
# Show the login form otherwise
#
 
any '/' => sub {
 
    my $self = shift;
 
    if ( $self->session('name') ) {
 
        return $self->redirect_to('/welcome');
 
    }
    else {
 
        $self->render( template => 'login' );
 
    }
 
};
 
#
# Change the default secret key for signing the cookies
# This passphrase is used by the HMAC-MD5 algorithm to make signed cookies
# secure and can be changed at any time to invalidate all existing sessions.
#
 
app->secret('9dd1571a116fccce362d54996c3d8c70c101cad5');
 
#
# Run!
#
 
app->start;
 
__DATA__
@@ layouts/default.html.ep
<!doctype html><html>
<head><title><%= title %></title></head>
<body><%= content %></body>
</html>
@@ login.html.ep
% layout 'default';
% title 'Login';
<h1>Log In</h1>
<% if (my $message = flash 'message' ) { %>
    <b><%= $message %></b><br>
<% } %>
<%= form_for login => (method => 'post') => begin %>
    Name: <%= text_field 'name' %>
    <br>
    Password: <%= password_field 'pass' %>
    <br>
    <%= submit_button 'Login' %>
<% end %>
@@ index.html.ep
% layout 'default';
% title 'Welcome';
<% if (my $message = flash 'message' ) { %>
    <b><%= $message %></b><br>
<% } %>
@@ welcome.html.ep
% title 'Welcome page';
<% if (my $message = flash 'message' ) { %>
    <b><%= $message %></b><br>
<% } %>
Welcome <%= session 'user' %>.<br>
<%= link_to Logout => 'logout' %>
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

Pero, para ser sincero, no entiendo nada.

Slds

por **explorer** » 2017-05-07 16:52 @745

Te pongo el código, comentado. Y abajo te explico el funcionamiento.

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
 
use Mojolicious::Lite;                                  # Aplicación simple
use Mojolicious::Plugin::Authentication;                # Complemento de autenticación
use Mojolicious::Plugin::Bcrypt;                        # Complemento de codificación
use Mojolicious::Plugin::Database;                      # Complemento de acceso a BD
use DBI;                                                # Funciones de acceso a BD
 
 
#
# La base de datos de autenticación contiene las cuentas de usuario
#
# Ejemplo de esquema:
# CREATE TABLE user (user_id integer primary key,
#                    user_name varchar,
#                    user_passwd varchar);
#
# La contraseña contiene un hash codificado con bcrypt
#
 
# Carga complemento de acceso a la base de datos
 
plugin 'database' => {
        dsn      => 'dbi:SQLite:dbname=auth',
        username => q{},
        password => q{},
        options  => { RaiseError => 1 },
        helper   => 'db',
};
 
 
# Usar codificación fuerte
 
plugin 'bcrypt';                                        
 
 
# Ejemplo de autenticación basado en base de datos
 
plugin 'authentication' => {
 
        # Subrutina para acceder a los datos del usuario
 
        load_user => sub {
                my ( $self, $uid ) = @_;
 
                # Creación de la consulta
                my $sth = $self->db->prepare(' select * from user where user_id=? ');
                $sth->execute($uid);
 
                # Hacer la consulta
                if ( my $res = $sth->fetchrow_hashref ) {
 
                        # Si la respuesta es afirmativa, devolvemos los datos
                        return $res;
 
                }
                else {
                        # Si ese usuario no existe o hay un error, salimos con error
                        return;
                }
 
        },
 
 
        # Subrutina para validar a un usuario
 
        validate_user => sub {
                my ( $self, $username, $password ) = @_;
 
                # Creación de la consulta
                my $sth
                        = $self->db->prepare(' select * from user where user_name = ? ');
                $sth->execute($username);
 
                # Regresar con error si la consulta no funcionó
                return unless $sth;
 
                if ( my $res = $sth->fetchrow_hashref ) {
 
                        # Esta línea no se usa (?)
                        my $salt = substr $password, 0, 2;              
 
                        # Comparar el $password que nos pasa el usuario con el que obtenemos de la BD
                        if ( $self->bcrypt_validate( $password, $res->{user_passwd} ) ) {
 
                                # Si la contraseña es correcta, creamos una sesión
                                $self->session(user => $username);
 
                                #
                                # Para los datos que deberían ser visibles solo para la siguiente petición,
                                # como un mensaje de confirmación después de un redirect 302, puedes usar
                                # flash.
                                #
                                $self->flash(message => 'Thanks for logging in.');
 
                                return $res->{user_id};
                        }
                        else {
                                # Devolvemos un error si no coincide la contraseña
                                return;
                        }
                }
                else {
                        # Devolvemos un error si falló la consulta
                        return;
                }
        },
};
 
#
# Esta página solo es visible para usuarios autenticados
#
 
any '/welcome' => sub {
        my $self = shift;
 
        if ( not $self->user_exists ) {
        
                # Si el usuario no existe, ponemos un mensaje de aviso, y lo enviamos a la página principal
 
                $self->flash( message => 'You must log in to view this page' );
                $self->redirect_to('/');
 
                return;
        }
        else {
                # Si el usuario existe, pintamos la pantalla de bienvenida
                $self->render( template => 'welcome' );
        }
};
 
#
# Intentar registrar la entrada del usuario
#
 
any '/login' => sub {
        my $self = shift;
 
        # Credenciales que nos manda el usuario por el formulario
        my $user = $self->param('name') || q{};
        my $pass = $self->param('pass') || q{};
 
        # Si el usuario se autentica de forma correcta
        if ( $self->authenticate( $user, $pass ) ) {
 
                # le llevamos a la página de bienvenida
                $self->redirect_to('/welcome');
        }
        else {
                # si no, mensaje de error y regresamos a pantalla principal
                $self->flash( message => 'Invalid credentials!' );
                $self->redirect_to('/');
        }
};
 
#
# Cerrar la sesión
#
 
any '/logout' => sub {
        my $self = shift;
 
        $self->session( expires => 1 );                 # Expirar la sesión
        $self->redirect_to('/');                        # Ir a página principal
};
 
#
# Si está registrado, mostramos la página de bienvenida
# Si no, mostramos el formulario de registro
#
 
any '/' => sub {
 
        my $self = shift;
 
        # Si hay sesión
        if ( $self->session('name') ) {
 
                # Ir a página de bienvenida
                return $self->redirect_to('/welcome');
        }
        else {
                # Si no, mostrar formulario de registro
                $self->render( template => 'login' );
        }
};
 
#
# Clave secreta que se usa para firmar las galletas (cookies)
# Esta frase de paso lo usa el algoritmo HMAC-MD5 para crear galletas firmadas
# seguras y se puede cambiar en cualquier momento para invalidar todas las sesiones actuales.
#
 
app->secret('9dd1571a116fccce362d54996c3d8c70c101cad5');
 
#
# ¡Ejecución!
#
 
app->start;
 
__DATA__
@@ layouts/default.html.ep
<!doctype html><html>
<head><title><%= title %></title></head>
<body><%= content %></body>
</html>
 
@@ login.html.ep
% layout 'default';
% title 'Login';
<h1>Log In</h1>
<% if (my $message = flash 'message' ) { %>
<b><%= $message %></b><br>
<% } %>
<%= form_for login => (method => 'post') => begin %>
Name: <%= text_field 'name' %>
<br>
Password: <%= password_field 'pass' %>
<br>
<%= submit_button 'Login' %>
<% end %>
 
@@ index.html.ep
% layout 'default';
% title 'Welcome';
<% if (my $message = flash 'message' ) { %>
<b><%= $message %></b><br>
<% } %>
 
@@ welcome.html.ep
% title 'Welcome page';
<% if (my $message = flash 'message' ) { %>
<b><%= $message %></b><br>
<% } %>
Welcome <%= session 'user' %>.<br>
<%= link_to Logout => 'logout' %>
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

De la línea 23 a la 108 se define cómo trabajarán los complementos. El acceso a la base de datos (BD) y cómo validar y recuperar la información del usuario. La subrutina de las líneas 43 a la 62 sirve para recuperar información del usuario, que es devolver todos los campos de la fila que corresponde al nombre del usuario. Y la subrutina de las líneas 67 a la 107 comprueba las credenciales.

A partir de la 114 a la 186 se definen las "rutas" por las que el usuario puede navegar. Por ejemplo, la ruta de la 114 es cuando el usuario va a 127.0.0.1:3000/welcome

El funcionamiento va a así:

Se supone que el usuario empieza por la ruta principal "/" (que es lo mismo que decir que no ha puesto ninguna ruta), así que lo primero que se ejecuta es la ruta de la línea 172. Allí se comprueba si existe una sesión. Como no existe, presentamos la plantilla con el formulario de registro de entrada. Ese formulario está en la plantilla 'login' que está en la sección __DATA__ (la que se llama login.html.ep).

Cuando el usuario rellena el formulario y pulsa el botón, entramos en la ruta de la línea 136, donde comprobamos las credenciales. Esa comprobación (línea 144) es la que llama a la subrutina comentada antes de la línea 67, donde crea la sesión. Si el usuario es correcto, lo reenviamos a "/welcome".

Ahora entramos por la línea 114. Si un usuario no autenticado intenta entrar directamente, lo llevamos de vuelta a la principal "/". Si no, le presentamos la plantilla "/welcome" (welcome.html.ep) con un mensaje de bienvenida, y un enlace para salir de la sesión.

Si el usuario pulsa ese enlace, entramos por la ruta de la línea 160, donde borramos la sesión y regresamos a la principal.

Finalmente, la aplicación arranca como programa independiente en la línea 200. Ahí se crea una aplicación web a la que te puedes conectar con el navegador yendo a la dirección 127.0.0.1:3000

Foro - Perl en Español

Módulos actuales en Perl

Módulos actuales en Perl

Publicidad

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

Re: Módulos actuales en Perl

¿Quién está conectado?