Autenticación vía HTTP

Aqui esta la version en python

from flask import make_response, request

def auth_required(func):
    def wrapper(self):
        if request.authorization and request.authorization['username'] == 'royer' and request.authorization['password'] == '1234':
            return func(self)
        
        return make_response('Could not verify your login!', 401, {'WWW-Autencticate': 'Basic reaml="Login Required"'})

    return wrapper

Luego se debe importar from common.auth import auth_required para despues llamarlo mediante el decorador @auth_required
Ejemplo

class BookList(Resource):
    @auth_required
    def get(self):
        return jsonify({'data': BOOKS})

Autenticación HTTP:
user:password@URL
$ curl http://mauro:1234@localhost:8000/books

Para proteger nuestros datos en nuestros servidor tenemos que crear una autenticación vía HTTP.

$user = array_key_exists( 'PHP_AUTH_USER', $_SERVER ) ? $_SERVER['PHP_AUTH_USER'] : '';
$pwd = array_key_exists( 'PHP_AUTH_PW', $_SERVER ) ? $_SERVER['PHP_AUTH_PW'] : '';

if ( $user !== 'katti' || $pwd !== '1234') {
    die;
}

Para poder acceder con usuario y clave, tenemos que ponerlos datos en la url en la terminal así:

curl http: // katti:1234@localhost:8000 /books

El problema que tiene la autenticación HTTP es:

• Poco segura → Porque toda la información de autenticación viaja por la url.
• Ineficiente → Porque cada veces que se realice una petición tienes que autenticarte.

Comprendo, no sabía que esto era autenticación vía HTTP, la usaba antes en GitHub al clonar repositorios privados, pero efectivamente parece poco seguro jaja

Que interesante la verdad estos ejemplos complementan mas claramente la clase de Outh2 de platzi.

En PHP la autenticación PHP se usan las variables:

• PHP_AUTH_USER
• PHP_AUTH_PW

Asi:

$user = array_key_exists('PHP_AUTH_USER', $_SERVER ) ?  $_SERVER['PHP_AUTH_USER'] : '';
$pass= array_key_exists('PHP_AUTH_PW', $_SERVER ) ?  $_SERVER['PHP_AUTH_PW'] : '';

Si la autenticacion es via HTTP el cliente en cada peticion debe enviar Usuario y contraseña por esa razon es un metodo no muy seguro.

HTTP soporta el uso de varios mecanismos de identificación para controlar el acceso a páginas u otros resources. Estos mecanismos se basan en el uso del código de estado 401 y el response header WWW-Authenticate.
Fuente: (https://diego.com.es/autenticacion-http)

Aquí mi intento con Javascript
Debido a que NodeJS recibe esta autenticación en base64 en los headers, hay que decodearlo.
Para esto hice un middleware autenticador, que es bastante sencillo de usar.

1. Creamos la función de autenticación bookAuthenticator

const bookAuthenticator = (req, res, next) => {  
  // Definimos nuestra variable que contendra la informacion de auth
  let authorization = [];

  // Verificamos si se envian headers de autenticación por HTTP
  if(req.headers.authorization) {
    // req.headers.authorization es encodeado en base64
    // Tal como: "Basic bHVjbmVvbmN0OjEyMzQ="
    // Con un Buffer lo decodeamos: Buffer.from('string','base64')
    authorization = Buffer
      // Separamos en dos arreglos, para usar solo el string encodeado
      // ["Basic", "bHVjbmVvbmN0OjEyMzQ="]
      .from(req.headers.authorization.split(" ")[1], 'base64')
      // Lo transformamos en utf-8
      // "lucneonct:1234"
      .toString('utf-8')
      // Lo separamos por el ":" en un array
      // ["lucneonct", "1234"]
      .split(':');
  }

  // Obtiene username del primer indice del arreglo y la contraseña del segundo
  const authUser = authorization[0];
  const authPassword = authorization[1];

  // Verificamos si los datos no coinciden con nuestro usuario hardcodeado
  if( authUser !== "Lucneonct" && authPassword !== "1234") {
    // Rompe la cadena y retorna un 403 Forbidden
    return res.status(403).json({ status: 'Forbidden: missing or invalid auth' });
  }

  // Seguimos con nuestro código una vez que todo esté bien
  next()
}

1. Usamos nuestro middleware bookAuthenticator en nuestra ruta get

app.get('/', bookAuthenticator, (req, res) => {
    // ... Nuestro código para obtener el libro
}

1. Lo probamos con

curl lucneonct:1234@localhost:5000/?resource_type=books | jq

Mi código de autenticación vía HTTP usando Python con FastAPI

Y la petición HTTP con las autenticación HTTP

Autenticación en Python Con Flask

# HTTP Autentication
auth = HTTPBasicAuth()

@auth.verify_password
def verify_password(username, password):
    if username == 'admin' and password == '123':
        return username

Y usar

class Books(Resource):
    @auth.login_required
    def get(self):
        return jsonify({'data': books})

Muy interesante conocer sobre este metodo de autenticacion y saber que no es el mas seguro que existe para tratar de evitarlo.

En el curso no he podido que me funcione el PUT. DELETE y la autenticación

http://**user:password@**URL

Autenticación para servicios muy básicos

la verdad no sabia ese metodo de authentication tan inseguro

Aqui encontre un link de como implementarlo en Go:
https://www.alexedwards.net/blog/basic-authentication-in-go

Para quienes usen flask este recurso puede ser útil:
https://www.youtube.com/watch?v=VW8qJxy4XcQ

<?php
// para la autenicación de usuarios con http se debe
// realizar los siguiente:
// 1. Se verifica: si el usuario enviado por la url existe
// 2. Se verifica: si el password enviado por la url existe
// 3. se verifica que el usuario y contraseña esten relacionados
$user = array_key_exists('PHP_AUTH_USER', $_SERVER) ? $_SERVER['PHP_AUTH_USER'] : ' '; //1.
$pwd = array_key_exists('PHP_AUTH_PW', $_SERVER) ? $_SERVER['PHP_AUTH_PW'] : '';      //2.
//3.

if ($user !== 'angel' || $pwd !== '1234') {
    echo 'Inicio de session: NO aprobado' . PHP_EOL;
    die;
} else {
    echo 'Inicio de session: Aprobado' . PHP_EOL;
}

autenticación vía HTTP

Para proteger los datos del servidor hay que crear una autenticación vía HTTP

# HTTP Autentication
auth = HTTPBasicAuth()

@auth.verify_password
def verify_password(username, password):
    if username == 'admin' and password == '123':
        return username

Luego se usa el decorador donde sea necesario

class Books(Resource):
    @auth.login_required
    def get(self):
        return jsonify({'data': books})

Y para realizar la petición con Curl

$ curl admin:123@localhost:8000/books

Muy buenas explicaciones, muy claro!

Autenticación or html, O: tan fácil como user:[email protected].
Pero no es muy segura

$_SERVER[‘PHP_AUTH_USER’];
$_SERVER[‘PHP_AUTH_PW’];
curl http://user:password@localhost:7000/books

¿Que hay de HTTPS?

La autenticación vía HTTP tiene dos problemas:

Es poco segura: las credenciales se envían en cada request anteponiendo el usuario y contraseña en la url, por ejemplo: user:[email protected].
Es ineficiente: la autenticación se debe realizar en cada request.

Apuntes:
Debemos basarnos en algunas variables que aporta PHP, las cuales son variables globales de servidor, para autenticación de usuario:
$_SERVER[‘PHP_AUTH_USER’]
Y para contraseña:
$_SERVER[‘PHP_AUTH_PW’]
Luego de una previa autenticacion, realizamos la petición en curl:
curl http://user:password@URL:8000

sip 😃

$user = array_key_exists(‘PHP_AUTH_USER’, $_SERVER ) ? $_SERVER[‘PHP_AUTH_USER’] : ‘’;
$pass= array_key_exists(‘PHP_AUTH_PW’, $_SERVER ) ? $_SERVER[‘PHP_AUTH_PW’] : ‘’;

Puede que no sea muy segura, pero es mejor que dejar la API expuesta como en los primeros ejercicios. Veamos que otras opciones hay de autenticación …

Me parece muy cruel de parte de mauro matar a todo el no autorizado que intenta entrar 😂

if( $user !== "mauro" && $pw !=="1234" ){

    die;
}```
Debe de haber una manera mas pacífica jajaja

Muy bueno la clase…

En el caso de PHP se pueden manejar sesiones para el control de acceso al API para la autenticación.

Duda: ¿en este caso sería ineficiente y poco segura?

Digo para no realizar la autenticación en cada request.

HTTP
curl htt p : // u ser : p w @ u ri : port

Cuando las validaciones no se cumplen siempre es bueno avisarle al usuario que esta sucediendo, al menos un echo