UNIVERSIDAD PRIVADA ANTENOR ORREGO

FACULTAD DE INGENIERÍA

INGENIERÍA DE COMPUTACIÓN Y SISTEMAS

Curso

Sistemas de Información Transaccional

Alumno

Del Aguila Quispe, Erwin Gian Pieer’s

Tema

Métodos de Securización de APIs

Docente

Jara García, Carlos Alberto

Trujillo – Perú

2022
INDICE: Método de securizacion de API

S
HTTP-based authentication scheme (basic and bearer token)..................3
¿Qué es?...................................................................................................................................3
Cuáles son las características...................................................................................................3
Cómo es el esquema de securización.......................................................................................3
Ejemplo de implementación....................................................................................................4
API keys..................................................................................................................................6
¿Qué es?...................................................................................................................................6
¿Cuáles son las características?................................................................................................6
Cómo es el esquema de securización.......................................................................................6
Código de implementación......................................................................................................6
OAuth2 (access token and refresh token), and..................................................7
¿Qué es?...................................................................................................................................7
Cuáles son las características...................................................................................................7
Cómo es el esquema de securización.......................................................................................7
Ejemplo de implementación....................................................................................................8
OpenID (e.g., Keycloak OpenID, BankID)...............................................................9
¿Qué es?...................................................................................................................................9
Cuáles son las características...................................................................................................9
Cómo es el esquema de securización.......................................................................................9
Ejemplo de implementación de c/u (código de ejemplo).......................................................10
Bibliografía...........................................................................................................................13
HTTP-based authentication scheme (basic and bearer token)
¿Qué es?
 la autenticación de acceso básica es un método diseñado para
permitir a un navegador web, u otro programa cliente, proveer
credenciales en la forma de usuario y contraseña cuando se le solicita
una página al servidor.

La autenticación al portador (también llamada autenticación de

token) tiene tokens de seguridad llamados tokens de portador. El
nombre "Autenticación al portador" se puede entender como "dar
acceso al portador de este token". El token al portador es una cadena
críptica, generalmente generada por el servidor en respuesta a una
solicitud de inicio de sesión. El cliente debe enviar este token en el
encabezado Authorization al realizar solicitudes a recursos protegidos:

Cuáles son las características

- consiste en coger el nombre de usuario, la contraseña,
separarlo por el símbolo de dos puntos y pasarlo a base 64.
Super seguro.
- que para no liarnos es como una especie de token con varias
propiedades, firmas e incluso alguna cosilla medio encriptada
- Un formato que nos permite la autorización en conjunto con la
autenticación de usuarios.

Cómo es el esquema de securización

Explicación: Para la autenticación básica, como el ID de usuario y la

contraseña se pasan a través de la red como texto no cifrado (está
 codificado en base64, pero base64 es una codificación reversible), el
esquema de autenticación básico no es seguro. HTTPS / TLS debe
usarse junto con la autenticación básica.

Explicación: De manera similar a la autenticación básica, la

autenticación al portador solo debe usarse a través de HTTPS (SSL).

Ejemplo de implementación
Authorization: Bearer <token> # al portador solo debe usarse a través de HTTPS (SSL).
Authorization
openapi: 3.0.0
...
1) Definir el tipo de esquema de seguridad(HTTP bearer)
components:
securitySchemes:
bearerAuth: #nombre arbitrario para el esquema de seguridad
type: http
scheme: bearer
bearerFormat: JWT # optional, arbitrary value for documentation purposes
# 2) Apply the security globally to all operations
security:
- bearerAuth: [] # use the same name as above

paths:
/something:
get:
security:
- bearerAuth: []

aths:
/something:
get:
...
responses:
'401':
$ref: '#/components/responses/UnauthorizedError'
...
post:
...
responses:
'401':
$ref: '#/components/responses/UnauthorizedError'
...
components:
responses:
UnauthorizedError:
description: Access token is missing or invalid
También puede definir la respuesta 401 "No autorizada" devuelta para las solicitudes
que no contienen un token de portador adecuado. Dado que la respuesta 401 será
utilizada por múltiples operaciones, puede definirla en la sección global y hacer
referencia en otro lugar a través de. components/responses$ref
API keys
¿Qué es?
es un identificador que sirve como el medio de autenticación de un
usuario para el uso de los servicios proporcionados por Sovos en los
Web Services o en el API Rest.

¿Cuáles son las características?

- permiten que servicios diferentes conecten y se comuniquen con
otros, de manera sencilla
- el acceso a APIs garantiza mayor flexibilidad en procesos de
transferencia de información
- través de ellas es posible crear capas de aplicaciones con el
objetivo de distribuir información a diferentes audiencias.

Cómo es el esquema de securización

Explicación: el estándar nos dice que las keys deberían viajar en el

Header de la petición, para dificultar un poco su acceso por parte de
terceros, aunque en la práctica se pueden ver en el Header
Authorization, en un Header personalizado o en la URL

Código de implementación

public class ApikeyConfiguration {

public string? ClientId {get; init;}
public string? Value {get; init;}
} // atributos a la api
public static class ApikeyDependencyInjection {
 public static IServiceCollection AddApiToken (this
IServiceCollection services, IConfiguration configuration)
return services. Configure<ApiKeyConfiguration> (configuration.
GetSection("Apikey"));
} // Esto hace que
cuando se ejecute la app, lea el contenido y lo mapee aquí.
"ApiKey”: {
"clientID: "1",
"value": "b92b0bdf-da95-42a8-a2b1-780ca461aaf3"
}//json mostrado

OAuth2 (access token and refresh token), and

¿Qué es?
es un framework de autorización, que permite a las aplicaciones
obtener acceso (limitado) a las cuentas de usuario de determinados
servicios, como Facebook, GitHub, Twitter y muchos más. Consiste en
delegar la autenticación de usuario al servicio que gestiona las
cuentas, de modo que sea éste quien otorgue el acceso para las
aplicaciones de terceros.

Cuáles son las características

- usuario delega la capacidad de realizar ciertas acciones, no todas,
a las cuales da su consentimiento para hacerlas en su nombre.
- Permitir a las aplicaciones autenticar usuarios sin tener que
almacenar y administrar contraseñas
- Permitir administrar su propia instancia OAuth que permita el acceso a los
recursos.
- define los valores para controlar el acceso a las operaciones de API
mediante el estándar de autorización OAuth.

Cómo es el esquema de securización

 Explicación: Una aplicación cliente (ya sea otra API o cualquier otra
aplicación) quiere acceder a un recurso, y para hacerlo solo le pide
autorización al propietario del recurso. Si todo va bien, acepta. Otorgar la
autorización lo enviará al servidor de autorización para obtener el token de
acceso y después de obtenerlo podemos ir al servidor de recursos para
obtener el recurso protegido.
Como se mencionó anteriormente, el servidor de autenticación y el servidor
de recursos pueden no ser de diferentes aplicaciones, sino del mismo
servidor.

Ejemplo de implementación

https://cliente.ejemplo.com/cb?code=AbCdEfGHiJK12345&state=xyz

 Con ese código podemos hacer una petición de tipo POST con esta estructura:

POST /token HTTP/1.1

Host: autorizacion.servidor.com

grant_type=authorization_code
&code=AbCdEfGHiJK12345
&redirect_uri=https://cliente.ejemplo.com/cb
&client_id=the-client-id
&client_secret=qwepuirqewipor09748nmenads

 Si todo es correcto, se obtendría la respuesta válida, que sería de este tipo:

HTTP/1.1 200 OK
Content-Type: application/json;charset=UTF-8
Cache-Control: no-store
Pragma: no-caché

{
“access_token”:”2YotnFZFEjr1zCsicMWpAA”,
“token_type”:”example”,
“expires_in”:3600,
“refresh_token”:”tGzv3JOkF0XG5Qx2TIKWIA”,
“example_parameter”:”example_value”
}

Con este token obtenido, se podría hacer, en nombre del cliente, todas las
cosas para lo que se hubiera dado el consentimiento.
OpenID (e.g., Keycloak OpenID, BankID).
¿Qué es?
es una capa de identidad sobre el protocolo OAuth 2.0, el cual permite
a los clientes verificar la identidad de un usuario basado en la
autenticación realizada por un servidor de autorización, así como para
obtener información de perfil del usuario utilizando un esquema REST.

Cuáles son las características

- Disminuir el spam de los comentarios en los blogs, tener la
seguridad de que los usuarios de un sistema son personas de
carne y hueso y agilizar nuestra identificación en la web 2.0
- El principal es que sólo necesitarás recordar un dato para acceder
a todos los servicios web que soporten este protocolo.
- El principal es que sólo necesitarás recordar un dato para acceder
a todos los servicios web que soporten este protocolo.

Cómo es el esquema de securización

Explicación:
 La aplicación solicita al usuario que se autentique.

a. Para ello, este es redirigido al servidor de autorización para su identificación.

Este puede logarse a través de usuario y contraseña, a través de
reconocimiento facial, de voz, puede tener un segundo factor de autenticación
o incluso se le puede permitir el acceso a través de otras cuentas que son del
usuario, como Google, Facebook, Amazon, etcétera. Lo que sea necesario
para verificar su identidad. Una vez que el usuario es validado, este debe estar
de acuerdo con lo que la aplicación quiere hacer (esto se llama
consentimiento). Normalmente se muestra una lista de los permisos que la
aplicación está solicitando.
b. Cuando la identidad del usuario es validada de manera satisfactoria, y este ha
consentido lo que se quiere hacer con esta autorización, el usuario es redirigido
de nuevo a la aplicación cliente. Le otorga a esta un código confirmando que
después de que el usuario se ha autenticado, este le autoriza hacer cosas por
él en el recurso protegido.
c. La aplicación cliente hace una solicitud al servidor de autorización, con el
permiso que el usuario le ha dado, además de algunos datos que identifican a
la aplicación para que se verifique que es un cliente válido para acceder a los
recursos que se propone.
d. Si todo va bien, el servidor de autorización responderá con un token de acceso
(access token en inglés).
e. Con este access token la aplicación cliente será capaz de realizar llamadas a la
API que necesita acceder para llevar a cabo su cometido.
f. Cuando el recurso protegido recibe el access token necesita verificarlo de
alguna forma. Una vez validado, comprobará si el usuario tiene los permisos
por los cuales se hizo la petición y, si está todo ok, la API responderá con los
datos que se le han pedido.

Ejemplo de implementación de c/u (código de ejemplo)

import httplib, urllib, base64, json, sys

class AuthError(Exception):
def __init__(self):
self.msg = "auth error"
def loadSecret():
try:
credsFile=open('brightcove_oauth.txt')
creds = json.load(credsFile)
return creds
except Exception, e:
print "Error loading oauth secret from local file called 'brightcove_oauth.txt'"
print "\tThere should be a local file in this directory called brightcove_oauth.txt "
print "\tWhich has contents like this:"
print """

{
 "account_id": "1234567890001",
"client_id": "30ff0909-0909-33d3-ae88-c9887777a7b7",
"client_secret": "mzKKjZZyeW5YgsdfBD37c5730g397agU35-Dsgeox6-
73giehbeihgleh659dhgjhdegessDge0s0ynegg987t0996nQ"
}

"""
sys.exit("System error: " + str(e) );
def getAuthToken(creds):
conn = httplib.HTTPSConnection("oauth.brightcove.com")
url = "/v4/access_token"
params = {
"grant_type": "client_credentials"
}
client = creds["client_id"];
client_secret = creds["client_secret"];
authString = base64.encodestring('%s:%s' % (client, client_secret)).replace('\n', '')
requestUrl = url + "?" + urllib.urlencode(params)
headersMap = {
"Content-Type": "application/x-www-form-urlencoded",
"Authorization": "Basic " + authString
};
conn.request("POST", requestUrl, headers=headersMap)
response = conn.getresponse()
if response.status == 200:
data = response.read()
result = json.loads( data )
return result["access_token"]
def getVideoViews( token , account ):
conn = httplib.HTTPSConnection("data.brightcove.com")
url = "/analytics-api/videocloud/account/" + account + "/report/"
params = {
"dimensions": "video",
"limit": "10",
"sort": "video_view",
"fields": "video,video_name,video_view",
"format": "json"
}
 requestUrl = url + "?" + urllib.urlencode(params)
headersMap = {
"Authorization": "Bearer " + token
};
conn.request("POST", requestUrl, headers=headersMap)
response = conn.getresponse()
if response.status == 200: data = response.read()
result = json.loads( data )
return result
elif response.status == 401:
raise AuthError
else:
raise Exception('API_CALL_ERROR' + " error " + str(response.status) )
def getVideos( token , account ):
conn = httplib.HTTPSConnection("cms.api.brightcove.com")
url = "/v1/accounts/" + account + "/counts/videos/"
requestUrl = url
print "GET " + requestUrl
headersMap = {
"Authorization": "Bearer " + token
};
conn.request("GET", requestUrl, headers=headersMap)
response = conn.getresponse()
if response.status == 200:
data = response.read()
result = json.loads( data )
return result
elif response.status == 401:
raise AuthError
else:
raise Exception('API_CALL_ERROR' + " error " + str(response.status) )
def demo():
creds = loadSecret()
token = getAuthToken(creds)
account = creds["account"];
try:
results = getVideos( token , account )
 except AuthError, e:
token = getAuthToken(creds)
results = getVideoViews( token , account )
print results
if __name__ == "__main__":
demo();

Bibliografía
(24 de 9 de 2020). Obtenido de https://help.conekta.com/hc/es-419/articles/360018086434--
Qu%C3%A9-son-las-API-Keys-y-d%C3%B3nde-las-encuentro-

(24 de 2 de 2021). Obtenido de https://soporte.reachcore.com/hc/es/articles/218092737-

Generar-API-Key-para-Web-Services

azabache, f. (2 de 4 de 2010). Obtenido de https://cloud.google.com/docs/authentication/api-

keys?hl=es-419

lujanmendesz. (2 de 4 de 2017). Obtenido de wordpress:

https://aprendiendoarduino.wordpress.com/tag/api-key/

pedro molet . (2 de 6 de 2015). Obtenido de

https://docs.aws.amazon.com/es_es/apigateway/latest/developerguide/api-gateway-
create-api-step-by-step.html

sout, f. (30 de 2 de 2022). chakray. Obtenido de https://www.chakray.com/es/oauth-2-0-

autenticacion-seguridad-y-usabilidad-de-api