size
int64 0
304k
| ext
stringclasses 1
value | lang
stringclasses 1
value | branch
stringclasses 1
value | content
stringlengths 0
304k
| avg_line_length
float64 0
238
| max_line_length
int64 0
304k
|
|---|---|---|---|---|---|---|
647 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2018 - TODAY, Open Source Integrators
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Field Service - Distribution",
"summary": "Manage your distribution structure",
"version": "15.0.1.0.0",
"category": "Field Service",
"author": "Open Source Integrators, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/field-service",
"depends": [
"fieldservice",
],
"data": [
"views/fsm_location.xml",
],
"application": False,
"license": "AGPL-3",
"development_status": "Beta",
"maintainers": [
"max3903",
],
}
| 28.130435 | 647 |
1,639 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2021 - TODAY, Open Source Integrators
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html)
from odoo.tests.common import TransactionCase
class TestFSMSDistribution(TransactionCase):
def setUp(self):
super(TestFSMSDistribution, self).setUp()
self.location = self.env["fsm.location"]
self.FSMOrder = self.env["fsm.order"]
self.test_loc_partner = self.env["res.partner"].create(
{"name": "Test Loc Partner 2", "phone": "123", "email": "[email protected]"}
)
self.test_location = self.env.ref("fieldservice.test_location")
self.test_location2 = self.location.create(
{
"name": "Test Location 2",
"phone": "123",
"email": "[email protected]",
"partner_id": self.test_loc_partner.id,
"owner_id": self.test_loc_partner.id,
"dist_parent_id": self.test_location.id,
"is_a_distribution": True,
}
)
self.test_location3 = self.location.create(
{
"name": "Test Location 2",
"phone": "123",
"email": "[email protected]",
"partner_id": self.test_loc_partner.id,
"owner_id": self.test_loc_partner.id,
}
)
def test_fsm_location(self):
"""Test creating new location, and test following functions."""
self.test_location._compute_distrib_sublocation_ids()
self.test_location.action_view_distrib_sublocation()
self.test_location3.action_view_distrib_sublocation()
| 39.97561 | 1,639 |
2,064 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2018 - TODAY, Open Source Integrators
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class FSMLocation(models.Model):
_inherit = "fsm.location"
is_a_distribution = fields.Boolean(string="Is a Distribution")
dist_parent_id = fields.Many2one("fsm.location", string="Distribution Parent")
distrib_count = fields.Integer(
compute="_compute_distrib_sublocation_ids",
string="# of distributed sub-locations",
)
def _compute_distrib_sublocation_ids(self):
for location in self:
location.distrib_count = self.env["fsm.location"].search_count(
[
("dist_parent_id", "=", location.id),
("id", "!=", location.id),
("is_a_distribution", "=", True),
]
)
def action_view_distrib_sublocation(self):
"""
This function returns an action that display existing
distribution sub-locations of a given fsm location id.
It can either be a in a list or in a form view, if there is only one
sub-location to show.
"""
for location in self:
action = self.env.ref("fieldservice.action_fsm_location").read()[0]
sublocation = self.env["fsm.location"].search(
[
("dist_parent_id", "=", location.id),
("id", "!=", location.id),
("is_a_distribution", "=", True),
]
)
if len(sublocation) == 1:
action["views"] = [
(
self.env.ref("fieldservice." + "fsm_location_form_view").id,
"form",
)
]
action["res_id"] = sublocation.id
else:
action["domain"] = [
("id", "in", sublocation.ids),
("is_a_distribution", "=", True),
]
return action
| 36.210526 | 2,064 |
508 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Auth JWT Test",
"summary": """
Test/demo module for auth_jwt.""",
"version": "14.0.1.2.0",
"license": "LGPL-3",
"author": "ACSONE SA/NV,Odoo Community Association (OCA)",
"maintainers": ["sbidoul"],
"website": "https://github.com/OCA/server-auth",
"depends": ["auth_jwt"],
"data": [],
"demo": ["demo/auth_jwt_validator.xml"],
"installable": False,
}
| 29.882353 | 508 |
2,082 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import time
import jwt
from odoo import tests
@tests.tagged("post_install", "-at_install")
class TestRegisterHook(tests.HttpCase):
def test_auth_method_exists(self):
validator = self.env["auth.jwt.validator"].search([("name", "=", "demo")])
self.assertEqual(len(validator), 1)
self.assertTrue(hasattr(self.env["ir.http"].__class__, "_auth_method_jwt_demo"))
def _get_token(self, aud=None, email=None):
validator = self.env["auth.jwt.validator"].search([("name", "=", "demo")])
payload = {
"aud": aud or validator.audience,
"iss": validator.issuer,
"exp": time.time() + 60,
}
if email:
payload["email"] = email
access_token = jwt.encode(
payload, key=validator.secret_key, algorithm=validator.secret_algorithm
)
return "Bearer " + access_token
def test_whoami(self):
"""A end-to-end test with positive authentication and partner retrieval."""
partner = self.env["res.users"].search([("email", "!=", False)])[0]
token = self._get_token(email=partner.email)
resp = self.url_open("/auth_jwt_demo/whoami", headers={"Authorization": token})
resp.raise_for_status()
whoami = resp.json()
self.assertEqual(whoami.get("name"), partner.name)
self.assertEqual(whoami.get("email"), partner.email)
# Try again in a user session, it will be rejected because auth_jwt
# is not designed to work in user session.
self.authenticate("demo", "demo")
resp = self.url_open("/auth_jwt_demo/whoami", headers={"Authorization": token})
self.assertEqual(resp.status_code, 401)
def test_forbidden(self):
"""A end-to-end test with negative authentication."""
token = self._get_token(aud="invalid")
resp = self.url_open("/auth_jwt_demo/whoami", headers={"Authorization": token})
self.assertEqual(resp.status_code, 401)
| 40.823529 | 2,082 |
2,295 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import json
from odoo.http import Controller, Response, request, route
class JWTTestController(Controller):
@route(
"/auth_jwt_demo/whoami",
type="http",
auth="jwt_demo",
csrf=False,
cors="*",
save_session=False,
methods=["GET", "OPTIONS"],
)
def whoami(self):
data = {}
if request.jwt_partner_id:
partner = request.env["res.partner"].browse(request.jwt_partner_id)
data.update(name=partner.name, email=partner.email)
return Response(json.dumps(data), content_type="application/json", status=200)
@route(
"/auth_jwt_demo/keycloak/whoami",
type="http",
auth="jwt_demo_keycloak",
csrf=False,
cors="*",
save_session=False,
methods=["GET", "OPTIONS"],
)
def whoami_keycloak(self):
"""To use with the demo_keycloak validator.
You can play with this using the browser app in tests/spa and the
identity provider in tests/keycloak.
"""
data = {}
if request.jwt_partner_id:
partner = request.env["res.partner"].browse(request.jwt_partner_id)
data.update(name=partner.name, email=partner.email)
return Response(json.dumps(data), content_type="application/json", status=200)
@route(
"/auth_jwt_demo/keycloak/whoami-public-or-jwt",
type="http",
auth="public_or_jwt_demo_keycloak",
csrf=False,
cors="*",
save_session=False,
methods=["GET", "OPTIONS"],
)
def whoami_public_or_keycloak(self):
"""To use with the demo_keycloak validator.
You can play with this using the browser app in tests/spa and the
identity provider in tests/keycloak.
"""
data = {}
if hasattr(request, "jwt_partner_id") and request.jwt_partner_id:
partner = request.env["res.partner"].browse(request.jwt_partner_id)
data.update(name=partner.name, email=partner.email)
else:
# public
data.update(name="Anonymous")
return Response(json.dumps(data), content_type="application/json", status=200)
| 33.26087 | 2,295 |
563 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2013-Today GRAP (http://www.grap.coop)
# @author Sylvain LE GAL (https://twitter.com/legalsylvain)
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
{
"name": "Authentification - System Administrator Passkey",
"summary": "Allows system administrator to authenticate with any account",
"version": "15.0.1.0.0",
"category": "base",
"author": "GRAP,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-auth",
"license": "AGPL-3",
"depends": ["mail"],
"installable": True,
}
| 37.533333 | 563 |
2,301 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2013-Today GRAP (http://www.grap.coop)
# @author Sylvain LE GAL (https://twitter.com/legalsylvain)
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from odoo import exceptions
from odoo.tests import common, tagged
from odoo.tools import config
@tagged("post_install", "-at_install")
class TestAuthAdminPasskey(common.TransactionCase):
"""Tests for 'Auth Admin Passkey' Module"""
def setUp(self):
super(TestAuthAdminPasskey, self).setUp()
self.ResUsers = self.env["res.users"]
self.db = self.env.cr.dbname
self.user_login = "auth_admin_passkey_user"
self.user_password = "Auth_admin_passkey_password*1"
self.sysadmin_passkey = "SysAdminPasskeyPa$$w0rd"
self.bad_password = "Bad_password*000001"
self.bad_login = "bad_login"
user = self.ResUsers.create(
{
"login": self.user_login,
"password": self.user_password,
"name": "auth_admin_passkey User",
}
)
self.user = user.with_user(user)
def test_01_normal_login_succeed(self):
self.user._check_credentials(self.user_password, {"interactive": True})
def test_02_normal_login_fail(self):
with self.assertRaises(exceptions.AccessDenied):
self.user._check_credentials(self.bad_password, {"interactive": True})
def test_03_normal_login_passkey_fail(self):
# This should failed, because feature is disabled
config["auth_admin_passkey_password"] = False
with self.assertRaises(exceptions.AccessDenied):
self.user._check_credentials(self.sysadmin_passkey, {"interactive": True})
def test_04_normal_login_passkey_succeed(self):
# This should succeed, because feature is enabled
config["auth_admin_passkey_password"] = self.sysadmin_passkey
self.user._check_credentials(self.sysadmin_passkey, {"interactive": True})
def test_05_passkey_login_passkey_succeed(self):
"""[Bug #1319391]
Test the correct behaviour of login with 'bad_login' / 'admin'"""
with self.assertRaises(exceptions.AccessDenied):
self.ResUsers.authenticate(
self.db, self.bad_login, self.sysadmin_passkey, {}
)
| 38.35 | 2,301 |
5,347 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2013-Today GRAP (http://www.grap.coop)
# @author Sylvain LE GAL (https://twitter.com/legalsylvain)
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
from lxml import html
from werkzeug.test import Client
from werkzeug.wrappers import BaseResponse
from odoo.service import wsgi_server
from odoo.tests import common, tagged
from odoo.tools import config
@tagged("post_install", "-at_install")
class TestUI(common.HttpCase):
def setUp(self):
super(TestUI, self).setUp()
with self.registry.cursor() as test_cursor:
env = self.env(test_cursor)
self.user_login = "auth_admin_passkey_user"
self.user_password = "Auth_admin_passkey_password*1"
self.sysadmin_passkey = "SysAdminPasskeyPa$$w0rd"
self.bad_password = "Bad_password*000001"
self.bad_login = "bad_login"
self.user = env["res.users"].create(
{
"login": self.user_login,
"password": self.user_password,
"name": "auth_admin_passkey User",
}
)
self.dbname = env.cr.dbname
self.werkzeug_environ = {"REMOTE_ADDR": "127.0.0.1"}
self.test_client = Client(wsgi_server.application, BaseResponse)
self.test_client.get("/web/session/logout")
def html_doc(self, response):
"""Get an HTML LXML document."""
return html.fromstring(response.data)
def csrf_token(self, response):
"""Get a valid CSRF token."""
doc = self.html_doc(response)
return doc.xpath("//input[@name='csrf_token']")[0].get("value")
def get_request(self, url, data=None):
return self.test_client.get(url, query_string=data, follow_redirects=True)
def post_request(self, url, data=None):
return self.test_client.post(
url, data=data, follow_redirects=True, environ_base=self.werkzeug_environ
)
def test_01_normal_login_succeed(self):
# Our user wants to go to backoffice part of Odoo
response = self.get_request("/web/", data={"db": self.dbname})
# He notices that his redirected to login page as not authenticated
self.assertIn("oe_login_form", response.data.decode("utf8"))
# He needs to enters his credentials and submit the form
data = {
"login": self.user_login,
"password": self.user_password,
"csrf_token": self.csrf_token(response),
"db": self.dbname,
}
response = self.post_request("/web/login/", data=data)
# He notices that his redirected to backoffice
self.assertNotIn("oe_login_form", response.data.decode("utf8"))
def test_02_normal_login_fail(self):
# Our user wants to go to backoffice part of Odoo
response = self.get_request("/web/", data={"db": self.dbname})
# He notices that he's redirected to login page as not authenticated
self.assertIn("oe_login_form", response.data.decode("utf8"))
# He needs to enter his credentials and submit the form
data = {
"login": self.user_login,
"password": self.bad_password,
"csrf_token": self.csrf_token(response),
"db": self.dbname,
}
response = self.post_request("/web/login/", data=data)
# He mistyped his password so he's redirected to login page again
self.assertIn("Wrong login/password", response.data.decode("utf8"))
def test_03_passkey_login_succeed(self):
# We enable auth_admin_passkey feature
config["auth_admin_passkey_password"] = self.sysadmin_passkey
# Our passkey user wants to go to backoffice part of Odoo
response = self.get_request("/web/", data={"db": self.dbname})
# He notices that he's redirected to login page as not authenticated
self.assertIn("oe_login_form", response.data.decode("utf8"))
# He needs to enter his credentials and submit the form
data = {
"login": self.user_login,
"password": self.sysadmin_passkey,
"csrf_token": self.csrf_token(response),
"db": self.dbname,
}
response = self.post_request("/web/login/", data=data)
# He notices that his redirected to backoffice
self.assertNotIn("oe_login_form", response.data.decode("utf8"))
def test_04_passkey_login_fail(self):
# We disable auth_admin_passkey feature
config["auth_admin_passkey_password"] = False
# Our passkey user wants to go to backoffice part of Odoo
response = self.get_request("/web/", data={"db": self.dbname})
# He notices that he's redirected to login page as not authenticated
self.assertIn("oe_login_form", response.data.decode("utf8"))
# He needs to enter his credentials and submit the form
data = {
"login": self.user_login,
"password": self.sysadmin_passkey,
"csrf_token": self.csrf_token(response),
"db": self.dbname,
}
response = self.post_request("/web/login/", data=data)
# Passkey feature is disabled so he's redirected to login page again
self.assertIn("Wrong login/password", response.data.decode("utf8"))
| 38.467626 | 5,347 |
2,539 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2013-Today GRAP (http://www.grap.coop)
# @author Sylvain LE GAL (https://twitter.com/legalsylvain)
# License AGPL-3 - See http://www.gnu.org/licenses/agpl-3.0.html
import logging
from datetime import datetime
from odoo import SUPERUSER_ID, _, api, exceptions, models
from odoo.tools import config
logger = logging.getLogger(__name__)
class ResUsers(models.Model):
_inherit = "res.users"
@api.model
def _send_email_passkey(self, login_user):
"""Send a email to the system administrator and / or the user
to inform passkey use."""
MailMail = self.env["mail.mail"].with_user(SUPERUSER_ID)
admin_user = self.with_user(SUPERUSER_ID).browse(SUPERUSER_ID)
send_to_user = config.get("auth_admin_passkey_send_to_user", True)
sysadmin_email = config.get("auth_admin_passkey_sysadmin_email", False)
mails = []
if sysadmin_email:
lang = config.get("auth_admin_passkey_sysadmin_lang", admin_user.lang)
mails.append({"email": sysadmin_email, "lang": lang})
if send_to_user and login_user.email:
mails.append({"email": login_user.email, "lang": login_user.lang})
for mail in mails:
subject, body_html = self._prepare_email_passkey(login_user)
MailMail.create(
{"email_to": mail["email"], "subject": subject, "body_html": body_html}
)
@api.model
def _prepare_email_passkey(self, login_user):
subject = _("Passkey used")
body = _(
"System Administrator user used his passkey to login"
" with %(login)s."
"\n\n\n\n"
"Technicals informations belows : \n\n"
"- Login date : %(login_date)s\n\n"
) % {
"login": login_user.login,
"login_date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
}
return subject, "<pre>%s</pre>" % body
def _check_credentials(self, password, env):
try:
return super(ResUsers, self)._check_credentials(password, env)
except exceptions.AccessDenied:
# Just be sure that parent methods aren't wrong
users = self.with_user(SUPERUSER_ID).search([("id", "=", self._uid)])
if not users:
raise
file_password = config.get("auth_admin_passkey_password", False)
if password and file_password == password:
self._send_email_passkey(users[0])
else:
raise
| 36.797101 | 2,539 |
1,256 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 LasLabs Inc.
# Copyright 2018 Modoolar <[email protected]>.
# Copyright 2019 initOS GmbH
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
{
"name": "Password Security",
"summary": "Allow admin to set password security requirements.",
"version": "15.0.1.1.4",
"author": "LasLabs, "
"Onestein, "
"Kaushal Prajapati, "
"Tecnativa, "
"initOS GmbH, "
"Omar Nasr, "
"Odoo Community Association (OCA)",
"category": "Base",
"depends": [
"auth_signup",
"auth_password_policy_signup",
],
"website": "https://github.com/OCA/server-auth",
"external_dependencies": {
"python": ["zxcvbn"],
},
"license": "LGPL-3",
"data": [
"views/res_config_settings_views.xml",
"security/ir.model.access.csv",
"security/res_users_pass_history.xml",
],
"assets": {
"web.assets_common": [
"/password_security/static/src/js/password_gauge.js",
"/password_security/static/lib/zxcvbn/zxcvbn.min.js",
],
"web.qunit_suite_tests": [
"password_security/static/tests/**/*",
],
},
"demo": [
"demo/res_users.xml",
],
"installable": True,
}
| 28.545455 | 1,256 |
3,100 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Onestein (<https://www.onestein.eu>)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo import http
from odoo.exceptions import UserError
from odoo.tests.common import HttpCase, Opener, get_db_name, new_test_user, tagged
@tagged("-at_install", "post_install")
class TestPasswordSecurityReset(HttpCase):
def setUp(self):
super().setUp()
# Create user with strong password: no error raised
new_test_user(self.env, "jackoneill", password="!asdQWE12345_3")
def reset_password(self, username):
"""Reset user password"""
db = get_db_name()
self.session = session = http.root.session_store.new()
session.db = db
http.root.session_store.save(session)
self.opener = Opener(self.cr)
self.opener.cookies["session_id"] = session.sid
res_post = self.url_open(
"/web/reset_password",
data={
"login": username,
"name": username,
"csrf_token": http.WebRequest.csrf_token(self),
},
)
res_post.raise_for_status()
return res_post
def test_01_reset_password_fail(self):
"""It should fail when reset password below Minimum Hours"""
# Enable check on Minimum Hours
self.env.company.password_minimum = 24
# Reset password
response = self.reset_password("jackoneill")
# Ensure we stay in the reset password page
self.assertEqual(response.request.path_url, "/web/reset_password")
self.assertEqual(response.status_code, 200)
self.assertIn(
"Passwords can only be reset every %s hour(s). "
"Please contact an administrator for assistance."
% self.env.company.password_minimum,
response.text,
)
def test_02_reset_password_success(self):
"""It should succeed when check on Minimum Hours is disabled"""
# Disable check on Minimum Hours
self.env.company.password_minimum = 0
# Reset password
response = self.reset_password("jackoneill")
# Password reset instructions sent to user's email
self.assertEqual(response.request.path_url, "/web/reset_password")
self.assertEqual(response.status_code, 200)
self.assertIn(
"An email has been sent with credentials to reset your password",
response.text,
)
def test_03_reset_password_admin(self):
"""It should succeed when reset password is executed by Admin"""
# Enable check on Minimum Hours
self.env.company.password_minimum = 24
# Executed by Admin: no error is raised
self.assertTrue(self.env.user._is_admin())
self.env["res.users"].reset_password("demo")
# Executed by non-admin user: error is raised
self.env = self.env(user=self.env.ref("base.user_demo"))
self.assertFalse(self.env.user._is_admin())
with self.assertRaises(UserError):
self.env["res.users"].reset_password("demo")
| 35.632184 | 3,100 |
5,164 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 LasLabs Inc.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo.exceptions import UserError
from odoo.tests.common import SavepointCase
class TestResUsers(SavepointCase):
@classmethod
def setUpClass(cls):
super(TestResUsers, cls).setUpClass()
cls.login = "[email protected]"
cls.partner_vals = {
"name": "Partner",
"is_company": False,
"email": cls.login,
}
cls.password = "asdQWE123$%^"
cls.main_comp = cls.env.ref("base.main_company")
cls.vals = {
"name": "User",
"login": cls.login,
"password": cls.password,
"company_id": cls.main_comp.id,
}
cls.model_obj = cls.env["res.users"]
cls.rec_id = cls._new_record()
@classmethod
def _new_record(cls):
partner_id = cls.env["res.partner"].create(cls.partner_vals)
cls.vals["partner_id"] = partner_id.id
return cls.model_obj.create(cls.vals)
def test_password_write_date_is_saved_on_create(self):
self.assertTrue(
self.rec_id.password_write_date,
"Password write date was not saved to db.",
)
def test_password_write_date_is_updated_on_write(self):
self.rec_id.write({"password_write_date": "1970-01-01 00:00:00"})
old_write_date = self.rec_id.password_write_date
self.rec_id.write({"password": "asdQWE123$%^2"})
new_write_date = self.rec_id.password_write_date
self.assertNotEqual(
old_write_date,
new_write_date,
"Password write date was not updated on write.",
)
def test_does_not_update_write_date_if_password_unchanged(self):
self.rec_id.write({"password_write_date": "1970-01-01 00:00:00"})
old_write_date = self.rec_id.password_write_date
self.rec_id.write({"name": "Luser"})
new_write_date = self.rec_id.password_write_date
self.assertEqual(
old_write_date,
new_write_date,
"Password not changed but write date updated anyway.",
)
def test_check_password_returns_true_for_valid_password(self):
self.assertTrue(
self.rec_id._check_password("asdQWE123$%^3"),
"Password is valid but check failed.",
)
def test_check_password_raises_error_for_invalid_password(self):
with self.assertRaises(UserError):
self.rec_id._check_password("password")
def test_save_password_crypt(self):
self.assertEqual(
1,
len(self.rec_id.password_history_ids),
)
def test_check_password_crypt(self):
"""It should raise UserError if previously used"""
with self.assertRaises(UserError):
self.rec_id.write({"password": self.password})
def test_password_is_expired_if_record_has_no_write_date(self):
self.rec_id.write({"password_write_date": None})
self.assertTrue(
self.rec_id._password_has_expired(),
"Record has no password write date but check failed.",
)
def test_an_old_password_is_expired(self):
old_write_date = "1970-01-01 00:00:00"
self.rec_id.write({"password_write_date": old_write_date})
self.assertTrue(
self.rec_id._password_has_expired(),
"Password is out of date but check failed.",
)
def test_a_new_password_is_not_expired(self):
self.assertFalse(
self.rec_id._password_has_expired(),
"Password was just created but has already expired.",
)
def test_expire_password_generates_token(self):
self.rec_id.sudo().action_expire_password()
token = self.rec_id.partner_id.signup_token
self.assertTrue(
token,
"A token was not generated.",
)
def test_validate_pass_reset_error(self):
"""It should throw UserError on reset inside min threshold"""
with self.assertRaises(UserError):
self.rec_id._validate_pass_reset()
def test_validate_pass_reset_allow(self):
"""It should allow reset pass when outside threshold"""
self.rec_id.password_write_date = "2016-01-01"
self.assertEqual(
True,
self.rec_id._validate_pass_reset(),
)
def test_validate_pass_reset_zero(self):
"""It should allow reset pass when <= 0"""
self.rec_id.company_id.password_minimum = 0
self.assertEqual(
True,
self.rec_id._validate_pass_reset(),
)
def test_underscore_is_special_character(self):
self.assertTrue(self.main_comp.password_special)
self.rec_id._check_password("asdQWE12345_3")
def test_user_with_admin_rights_can_create_users(self):
demo = self.env.ref("base.user_demo")
demo.groups_id |= self.env.ref("base.group_erp_manager")
test1 = self.model_obj.with_user(demo).create(
{
"login": "test1",
"name": "test1",
}
)
test1.unlink()
| 35.129252 | 5,164 |
2,055 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 LasLabs Inc.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from contextlib import contextmanager
from unittest import mock
from odoo.http import _request_stack
from odoo.tests.common import TransactionCase
from ..controllers import main
IMPORT = "odoo.addons.password_security.controllers.main"
class EndTestException(Exception):
"""It allows for isolation of resources by raise"""
class TestPasswordSecuritySession(TransactionCase):
def setUp(self):
super(TestPasswordSecuritySession, self).setUp()
self.PasswordSecuritySession = main.PasswordSecuritySession
self.password_security_session = self.PasswordSecuritySession()
self.passwd = "I am a password!"
self.fields = [
{"name": "new_password", "value": self.passwd},
]
_request_stack.push(
mock.Mock(
env=self.env,
)
)
self.addCleanup(_request_stack.pop)
@contextmanager
def mock_assets(self):
"""It mocks and returns assets used by this controller"""
with mock.patch("%s.request" % IMPORT) as request:
yield {
"request": request,
}
def test_change_password_check(self):
"""It should check password on request user"""
with self.mock_assets() as assets:
check_password = assets["request"].env.user._check_password
check_password.side_effect = EndTestException
with self.assertRaises(EndTestException):
self.password_security_session.change_password(self.fields)
check_password.assert_called_once_with(
self.passwd,
)
def test_change_password_return(self):
"""It should return result of super"""
with self.mock_assets():
with mock.patch.object(main.Session, "change_password") as chg:
res = self.password_security_session.change_password(self.fields)
self.assertEqual(chg(), res)
| 34.830508 | 2,055 |
1,784 |
py
|
PYTHON
|
15.0
|
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo.exceptions import UserError
from odoo.tests.common import TransactionCase
class TestPasswordHistory(TransactionCase):
def test_check_password_history(self):
# Disable all password checks except for history
set_param = self.env["ir.config_parameter"].sudo().set_param
set_param("auth_password_policy.minlength", 0)
user = self.env.ref("base.user_admin")
user.company_id.update(
{
"password_estimate": 0,
"password_length": 0,
"password_lower": 0,
"password_history": 1,
"password_numeric": 0,
"password_special": 0,
"password_upper": 0,
}
)
self.assertEqual(len(user.password_history_ids), 0)
user.write({"password": "admin"})
self.assertEqual(len(user.password_history_ids), 1)
with self.assertRaises(UserError):
user.write({"password": "admin"})
user.write({"password": "admit"})
self.assertEqual(len(user.password_history_ids), 2)
user.company_id.password_history = 2
with self.assertRaises(UserError):
user.write({"password": "admin"})
with self.assertRaises(UserError):
user.write({"password": "admit"})
user.write({"password": "badminton"})
self.assertEqual(len(user.password_history_ids), 3)
user.company_id.password_history = 0
user.write({"password": "badminton"})
self.assertEqual(len(user.password_history_ids), 4)
user.company_id.password_history = -1
with self.assertRaises(UserError):
user.write({"password": "admin"})
| 36.408163 | 1,784 |
8,036 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 LasLabs Inc.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from contextlib import contextmanager
from datetime import datetime, timedelta
from unittest import mock
from werkzeug.urls import url_parse
from odoo.exceptions import UserError
from odoo.http import Response, _request_stack
from odoo.tests.common import HttpCase, TransactionCase
from ..controllers import main
IMPORT = "odoo.addons.password_security.controllers.main"
class EndTestException(Exception):
"""It allows for isolation of resources by raise"""
class MockResponse(object):
def __new__(cls):
return mock.Mock(spec=Response)
class MockPassError(UserError):
def __init__(self):
super(MockPassError, self).__init__("Message")
class TestPasswordSecurityHome(TransactionCase):
def setUp(self):
super(TestPasswordSecurityHome, self).setUp()
self.PasswordSecurityHome = main.PasswordSecurityHome
self.password_security_home = self.PasswordSecurityHome()
self.passwd = "I am a password!"
self.qcontext = {
"password": self.passwd,
}
_request_stack.push(
mock.Mock(
env=self.env,
)
)
self.addCleanup(_request_stack.pop)
@contextmanager
def mock_assets(self):
"""It mocks and returns assets used by this controller"""
methods = [
"do_signup",
"web_login",
"web_auth_signup",
"web_auth_reset_password",
]
with mock.patch.multiple(
main.AuthSignupHome, **{m: mock.DEFAULT for m in methods}
) as _super:
mocks = {}
for method in methods:
mocks[method] = _super[method]
mocks[method].return_value = MockResponse()
with mock.patch("%s.request" % IMPORT) as request:
with mock.patch("%s.ensure_db" % IMPORT) as ensure:
with mock.patch("%s.http" % IMPORT) as http:
http.request.redirect.return_value = MockResponse()
mocks.update(
{
"request": request,
"ensure_db": ensure,
"http": http,
}
)
yield mocks
def test_do_signup_check(self):
"""It should check password on user"""
with self.mock_assets() as assets:
check_password = assets["request"].env.user._check_password
check_password.side_effect = EndTestException
with self.assertRaises(EndTestException):
self.password_security_home.do_signup(self.qcontext)
check_password.assert_called_once_with(
self.passwd,
)
def test_do_signup_return(self):
"""It should return result of super"""
with self.mock_assets() as assets:
res = self.password_security_home.do_signup(self.qcontext)
self.assertEqual(assets["do_signup"](), res)
def test_web_login_ensure_db(self):
"""It should verify available db"""
with self.mock_assets() as assets:
assets["ensure_db"].side_effect = EndTestException
with self.assertRaises(EndTestException):
self.password_security_home.web_login()
def test_web_login_super(self):
"""It should call superclass w/ proper args"""
expect_list = [1, 2, 3]
expect_dict = {"test1": "good1", "test2": "good2"}
with self.mock_assets() as assets:
assets["web_login"].side_effect = EndTestException
with self.assertRaises(EndTestException):
self.password_security_home.web_login(*expect_list, **expect_dict)
assets["web_login"].assert_called_once_with(*expect_list, **expect_dict)
def test_web_login_log_out_if_expired(self):
"""It should log out user if password expired"""
with self.mock_assets() as assets:
request = assets["request"]
request.httprequest.method = "POST"
user = request.env["res.users"].sudo().browse()
user._password_has_expired.return_value = True
self.password_security_home.web_login()
logout_mock = request.session.logout
logout_mock.assert_called_once_with(keep_db=True)
def test_web_login_redirect(self):
"""It should redirect w/ hash to reset after expiration"""
with self.mock_assets() as assets:
request = assets["request"]
request.httprequest.method = "POST"
user = request.env["res.users"].sudo().browse()
user._password_has_expired.return_value = True
res = self.password_security_home.web_login()
self.assertEqual(
request.redirect(),
res,
)
def test_web_auth_signup_valid(self):
"""It should return super if no errors"""
with self.mock_assets() as assets:
res = self.password_security_home.web_auth_signup()
self.assertEqual(
assets["web_auth_signup"](),
res,
)
def test_web_auth_signup_invalid_qcontext(self):
"""It should catch PassError and get signup qcontext"""
with self.mock_assets() as assets:
with mock.patch.object(
main.AuthSignupHome,
"get_auth_signup_qcontext",
) as qcontext:
assets["web_auth_signup"].side_effect = MockPassError
qcontext.side_effect = EndTestException
with self.assertRaises(EndTestException):
self.password_security_home.web_auth_signup()
def test_web_auth_signup_invalid_render(self):
"""It should render & return signup form on invalid"""
with self.mock_assets() as assets:
with mock.patch.object(
main.AuthSignupHome, "get_auth_signup_qcontext", spec=dict
) as qcontext:
assets["web_auth_signup"].side_effect = MockPassError
res = self.password_security_home.web_auth_signup()
assets["request"].render.assert_called_once_with(
"auth_signup.signup",
qcontext(),
)
self.assertEqual(
assets["request"].render(),
res,
)
@mock.patch("odoo.http.WebRequest.validate_csrf", return_value=True)
class LoginCase(HttpCase):
def test_web_login_authenticate(self, *args):
"""It should allow authenticating by login"""
response = self.url_open(
"/web/login",
{"login": "admin", "password": "admin"},
)
# Redirected to /web because it succeeded
path = url_parse(response.url).path
self.assertEqual(path, "/web")
self.assertEqual(response.status_code, 200)
def test_web_login_authenticate_fail(self, *args):
"""It should fail auth"""
response = self.url_open(
"/web/login",
{"login": "admin", "password": "noadmin"},
)
self.assertIn(
"Wrong login/password",
response.text,
)
def test_web_login_expire_pass(self, *args):
"""It should expire password if necessary"""
three_days_ago = datetime.now() - timedelta(days=3)
with self.cursor() as cr:
env = self.env(cr)
user = env["res.users"].search([("login", "=", "admin")])
user.password_write_date = three_days_ago
user.company_id.password_expiration = 1
response = self.url_open(
"/web/login",
{"login": "admin", "password": "admin"},
)
path = url_parse(response.url).path
self.assertEqual(path, "/web/reset_password")
| 37.7277 | 8,036 |
813 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Onestein (<https://www.onestein.eu>)
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
class TestConfigSettings(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.config = cls.env["res.config.settings"].create({})
def test_01_password_estimate_range(self):
"""The estimation must be between 0 and 4"""
self.config.password_estimate = 0
self.config.password_estimate = 2
self.config.password_estimate = 4
with self.assertRaises(ValidationError):
self.config.password_estimate = 5
with self.assertRaises(ValidationError):
self.config.password_estimate = -1
| 33.875 | 813 |
618 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 LasLabs Inc.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo import fields, models
class ResUsersPassHistory(models.Model):
_name = "res.users.pass.history"
_description = "Res Users Password History"
_order = "user_id, date desc"
user_id = fields.Many2one(
string="User",
comodel_name="res.users",
ondelete="cascade",
index=True,
)
password_crypt = fields.Char(
string="Encrypted Password",
)
date = fields.Datetime(
default=lambda s: fields.Datetime.now(),
index=True,
)
| 24.72 | 618 |
1,885 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 LasLabs Inc.
# Copyright 2017 Kaushal Prajapati <[email protected]>.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class ResCompany(models.Model):
_inherit = "res.company"
password_expiration = fields.Integer(
"Days",
default=60,
help="How many days until passwords expire",
)
password_length = fields.Integer(
"Characters",
default=12,
help="Minimum number of characters",
)
password_lower = fields.Integer(
"Lowercase",
default=1,
help="Require number of lowercase letters",
)
password_upper = fields.Integer(
"Uppercase",
default=1,
help="Require number of uppercase letters",
)
password_numeric = fields.Integer(
"Numeric",
default=1,
help="Require number of numeric digits",
)
password_special = fields.Integer(
"Special",
default=1,
help="Require number of unique special characters",
)
password_estimate = fields.Integer(
"Estimation",
default=3,
help="Required score for the strength estimation. Between 0 and 4",
)
password_history = fields.Integer(
"History",
default=30,
help="Disallow reuse of this many previous passwords - use negative "
"number for infinite, or 0 to disable",
)
password_minimum = fields.Integer(
"Minimum Hours",
default=24,
help="Amount of hours until a user may change password again",
)
@api.constrains("password_estimate")
def _check_password_estimate(self):
if self.password_estimate < 0 or self.password_estimate > 4:
raise ValidationError(_("The estimation must be between 0 and 4."))
| 30.403226 | 1,885 |
7,724 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 LasLabs Inc.
# Copyright 2017 Kaushal Prajapati <[email protected]>.
# Copyright 2018 Modoolar <[email protected]>.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
import logging
import re
from datetime import datetime, timedelta
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
_logger = logging.getLogger(__name__)
try:
import zxcvbn
zxcvbn.feedback._ = _
except ImportError:
_logger.debug(
"Could not import zxcvbn. Please make sure this library is available"
" in your environment."
)
def delta_now(**kwargs):
dt = datetime.now() + timedelta(**kwargs)
return fields.Datetime.to_string(dt)
class ResUsers(models.Model):
_inherit = "res.users"
password_write_date = fields.Datetime(
"Last password update", default=fields.Datetime.now, readonly=True
)
password_history_ids = fields.One2many(
string="Password History",
comodel_name="res.users.pass.history",
inverse_name="user_id",
readonly=True,
)
@api.model
def create(self, vals):
vals["password_write_date"] = fields.Datetime.now()
return super(ResUsers, self).create(vals)
def write(self, vals):
if vals.get("password"):
self._check_password(vals["password"])
vals["password_write_date"] = fields.Datetime.now()
return super(ResUsers, self).write(vals)
@api.model
def get_password_policy(self):
data = super(ResUsers, self).get_password_policy()
company_id = self.env.user.company_id
data.update(
{
"password_lower": company_id.password_lower,
"password_upper": company_id.password_upper,
"password_numeric": company_id.password_numeric,
"password_special": company_id.password_special,
"password_length": company_id.password_length,
"password_estimate": company_id.password_estimate,
}
)
return data
def _check_password_policy(self, passwords):
result = super(ResUsers, self)._check_password_policy(passwords)
for password in passwords:
if not password:
continue
self._check_password(password)
return result
@api.model
def get_estimation(self, password):
return zxcvbn.zxcvbn(password)
def password_match_message(self):
self.ensure_one()
company_id = self.company_id
message = []
if company_id.password_lower:
message.append(
_("\n* Lowercase letter (at least %s characters)")
% str(company_id.password_lower)
)
if company_id.password_upper:
message.append(
_("\n* Uppercase letter (at least %s characters)")
% str(company_id.password_upper)
)
if company_id.password_numeric:
message.append(
_("\n* Numeric digit (at least %s characters)")
% str(company_id.password_numeric)
)
if company_id.password_special:
message.append(
_("\n* Special character (at least %s characters)")
% str(company_id.password_special)
)
if message:
message = [_("Must contain the following:")] + message
if company_id.password_length:
message = [
_("Password must be %d characters or more.")
% company_id.password_length
] + message
return "\r".join(message)
def _check_password(self, password):
self._check_password_rules(password)
self._check_password_history(password)
return True
def _check_password_rules(self, password):
self.ensure_one()
if not password:
return True
company_id = self.company_id
password_regex = [
"^",
"(?=.*?[a-z]){" + str(company_id.password_lower) + ",}",
"(?=.*?[A-Z]){" + str(company_id.password_upper) + ",}",
"(?=.*?\\d){" + str(company_id.password_numeric) + ",}",
r"(?=.*?[\W_]){" + str(company_id.password_special) + ",}",
".{%d,}$" % int(company_id.password_length),
]
if not re.search("".join(password_regex), password):
raise ValidationError(self.password_match_message())
estimation = self.get_estimation(password)
if estimation["score"] < company_id.password_estimate:
raise UserError(estimation["feedback"]["warning"])
return True
def _password_has_expired(self):
self.ensure_one()
if not self.password_write_date:
return True
if not self.company_id.password_expiration:
return False
days = (fields.Datetime.now() - self.password_write_date).days
return days > self.company_id.password_expiration
def action_expire_password(self):
expiration = delta_now(days=+1)
for rec_id in self:
rec_id.mapped("partner_id").signup_prepare(
signup_type="reset", expiration=expiration
)
def _validate_pass_reset(self):
"""It provides validations before initiating a pass reset email
:raises: UserError on invalidated pass reset attempt
:return: True on allowed reset
"""
for user in self:
pass_min = user.company_id.password_minimum
if pass_min <= 0:
continue
write_date = user.password_write_date
delta = timedelta(hours=pass_min)
if write_date + delta > datetime.now():
raise UserError(
_(
"Passwords can only be reset every %d hour(s). "
"Please contact an administrator for assistance."
)
% pass_min
)
return True
def _check_password_history(self, password):
"""It validates proposed password against existing history
:raises: UserError on reused password
"""
crypt = self._crypt_context()
for user in self:
password_history = user.company_id.password_history
if not password_history: # disabled
recent_passes = self.env["res.users.pass.history"].browse()
elif password_history < 0: # unlimited
recent_passes = user.password_history_ids
else:
recent_passes = user.password_history_ids[:password_history]
if recent_passes.filtered(
lambda r: crypt.verify(password, r.password_crypt)
):
raise UserError(
_("Cannot use the most recent %d passwords")
% user.company_id.password_history
)
def _set_encrypted_password(self, uid, pw):
"""It saves password crypt history for history rules"""
res = super(ResUsers, self)._set_encrypted_password(uid, pw)
self.write({"password_history_ids": [(0, 0, {"password_crypt": pw})]})
return res
def action_reset_password(self):
"""Disallow password resets inside of Minimum Hours"""
if not self.env.context.get("install_mode") and not self.env.context.get(
"create_user"
):
if not self.env.user._is_admin():
users = self.filtered(lambda user: user.active)
users._validate_pass_reset()
return super().action_reset_password()
| 35.269406 | 7,724 |
1,168 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Modoolar <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo import fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
password_expiration = fields.Integer(
related="company_id.password_expiration", readonly=False
)
password_minimum = fields.Integer(
related="company_id.password_minimum", readonly=False
)
password_history = fields.Integer(
related="company_id.password_history", readonly=False
)
password_length = fields.Integer(
related="company_id.password_length", readonly=False
)
password_lower = fields.Integer(related="company_id.password_lower", readonly=False)
password_upper = fields.Integer(related="company_id.password_upper", readonly=False)
password_numeric = fields.Integer(
related="company_id.password_numeric", readonly=False
)
password_special = fields.Integer(
related="company_id.password_special", readonly=False
)
password_estimate = fields.Integer(
related="company_id.password_estimate", readonly=False
)
| 37.677419 | 1,168 |
2,257 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 LasLabs Inc.
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
import operator
from odoo import http
from odoo.exceptions import UserError
from odoo.http import request
from odoo.addons.auth_signup.controllers.main import AuthSignupHome
from odoo.addons.web.controllers.main import Session, ensure_db
class PasswordSecuritySession(Session):
@http.route()
def change_password(self, fields):
new_password = operator.itemgetter("new_password")(
dict(list(map(operator.itemgetter("name", "value"), fields)))
)
user_id = request.env.user
user_id._check_password(new_password)
return super(PasswordSecuritySession, self).change_password(fields)
class PasswordSecurityHome(AuthSignupHome):
def do_signup(self, qcontext):
password = qcontext.get("password")
user_id = request.env.user
user_id._check_password(password)
return super(PasswordSecurityHome, self).do_signup(qcontext)
@http.route("/password_security/estimate", auth="none", type="json")
def estimate(self, password):
return request.env["res.users"].get_estimation(password)
@http.route()
def web_login(self, *args, **kw):
ensure_db()
response = super(PasswordSecurityHome, self).web_login(*args, **kw)
if not request.params.get("login_success"):
return response
# Now, I'm an authenticated user
if not request.env.user._password_has_expired():
return response
# My password is expired, kick me out
request.env.user.action_expire_password()
request.session.logout(keep_db=True)
# I was kicked out, so set login_success in request params to False
request.params["login_success"] = False
redirect = request.env.user.partner_id.signup_url
return request.redirect(redirect)
@http.route()
def web_auth_signup(self, *args, **kw):
try:
return super(PasswordSecurityHome, self).web_auth_signup(*args, **kw)
except UserError as e:
qcontext = self.get_auth_signup_qcontext()
qcontext["error"] = str(e)
return request.render("auth_signup.signup", qcontext)
| 37.616667 | 2,257 |
738 |
py
|
PYTHON
|
15.0
|
# Copyright 2012-2018 Therp BV <https://therp.nl>
# Copyright 2018 Brainbean Apps <https://brainbeanapps.com>
# Copyright 2021 Tecnativa - João Marques
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "LDAP groups assignment",
"version": "15.0.1.0.0",
"depends": ["auth_ldap"],
"author": "Therp BV, " "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-auth",
"license": "AGPL-3",
"summary": "Adds user accounts to groups based on rules defined "
"by the administrator.",
"category": "Authentication",
"data": ["views/res_company_ldap_views.xml", "security/ir.model.access.csv"],
"external_dependencies": {"python": ["python-ldap"]},
}
| 43.352941 | 737 |
7,998 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Therp BV <https://therp.nl>
# Copyright 2018 Brainbean Apps <https://brainbeanapps.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from contextlib import contextmanager
from unittest import mock
from odoo.exceptions import UserError
from odoo.tests.common import TransactionCase
_auth_ldap_ns = "odoo.addons.auth_ldap"
_company_ldap_class = _auth_ldap_ns + ".models.res_company_ldap.CompanyLDAP"
@contextmanager
def mock_cursor(cr):
with mock.patch("odoo.sql_db.Connection.cursor") as mocked_cursor_call:
org_close = cr.close
org_autocommit = cr.autocommit
try:
cr.close = mock.Mock()
cr.autocommit = mock.Mock()
cr.commit = mock.Mock()
mocked_cursor_call.return_value = cr
yield
finally:
cr.close = org_close
cr.autocommit = org_autocommit
class FakeLdapConnection(object):
def __init__(self, entries):
self.entries = entries
def simple_bind_s(self, dn, passwd):
pass
def search_st(self, dn, scope, ldap_filter, attributes, timeout):
if dn in self.entries:
return [(dn, dict(self.entries[dn]))]
return []
def unbind(self):
pass
def unbind_s(self):
pass
def __getattr__(self, name):
def wrapper():
raise Exception("'%s' is not mocked" % name)
return wrapper
class TestUsersLdapGroups(TransactionCase):
def setUp(self):
super().setUp()
self.group_system = self.env.ref("base.group_system")
self.group_user = self.env.ref("base.group_user")
self.group_contains = self.env["res.groups"].create({"name": "contains"})
self.group_equals = self.env["res.groups"].create({"name": "equals"})
self.group_query = self.env["res.groups"].create({"name": "query"})
def _create_ldap_config(self, groups, only_ldap_groups=False, cr=None):
vals = {
"company": self.env.ref("base.main_company").id,
"ldap_base": "dc=users_ldap_groups,dc=example,dc=com",
"ldap_filter": "(uid=%s)",
"ldap_binddn": "cn=bind,dc=example,dc=com",
"create_user": True,
"only_ldap_groups": only_ldap_groups,
"group_mapping_ids": [(0, 0, group) for group in groups],
}
return self.env["res.company.ldap"].create(vals)
def test_users_ldap_groups_only_true(self):
self._create_ldap_config(
groups=[
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello3",
"group_id": self.group_system.id,
},
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello",
"group_id": self.group_user.id,
},
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello2",
"group_id": self.group_contains.id,
},
{
"ldap_attribute": "name",
"operator": "equals",
"value": "hello",
"group_id": self.group_equals.id,
},
{
"ldap_attribute": "",
"operator": "query",
"value": "is not run because of patching",
"group_id": self.group_query.id,
},
],
only_ldap_groups=True,
)
# _login does its work in a new cursor, so we need to mock it
with mock.patch(
_company_ldap_class + "._connect",
return_value=FakeLdapConnection(
{
"dc=users_ldap_groups,dc=example,dc=com": {
"cn": [b"User Name"],
"name": [b"hello", b"hello2"],
}
}
),
), mock_cursor(self.cr):
user_id = (
self.env["res.users"]
.sudo()
.authenticate(
self.env.cr.dbname, "users_ldap_groups-username", "password", {}
)
)
# this asserts group mappings from demo data
user = self.env["res.users"].sudo().browse(user_id)
groups = user.groups_id
self.assertIn(self.group_contains, groups)
self.assertIn(self.group_user, groups)
self.assertNotIn(self.group_equals, groups)
self.assertIn(self.group_query, groups)
self.assertNotIn(self.group_system, groups)
def test_users_ldap_groups_only_false(self):
self._create_ldap_config(
groups=[
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello2",
"group_id": self.group_contains.id,
},
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello",
"group_id": self.group_equals.id,
},
],
only_ldap_groups=False,
)
with mock.patch(
_company_ldap_class + "._connect",
return_value=FakeLdapConnection(
{
"dc=users_ldap_groups,dc=example,dc=com": {
"cn": [b"User Name"],
"name": [b"hello", b"hello2"],
}
}
),
), mock_cursor(self.cr):
user_id = (
self.env["res.users"]
.sudo()
.authenticate(
self.env.cr.dbname, "users_ldap_groups-username", "password", {}
)
)
# this asserts group mappings from demo data
user = self.env["res.users"].sudo().browse(user_id)
groups = user.groups_id
self.assertIn(self.group_contains, groups)
self.assertIn(self.group_equals, groups)
self.assertGreater(len(groups), 2) # user should keep default groups
def _test_users_ldap_groups_not_user_type(self):
self._create_ldap_config(
groups=[
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello3",
"group_id": self.group_system.id,
},
{
"ldap_attribute": "name",
"operator": "contains",
"value": "hello2",
"group_id": self.group_contains.id,
},
{
"ldap_attribute": "name",
"operator": "equals",
"value": "hello",
"group_id": self.group_equals.id,
},
{
"ldap_attribute": "",
"operator": "query",
"value": "is not run because of patching",
"group_id": self.group_query.id,
},
],
only_ldap_groups=True,
)
with mock.patch(
_company_ldap_class + "._connect",
return_value=FakeLdapConnection(
{
"dc=users_ldap_groups,dc=example,dc=com": {
"cn": [b"User Name"],
"name": [b"hello", b"hello2"],
}
}
),
), mock_cursor(self.cr):
with self.assertRaises(UserError):
self.env["res.users"].sudo().authenticate(
self.env.cr.dbname, "users_ldap_groups-username", "password", {}
)
| 35.23348 | 7,998 |
1,473 |
py
|
PYTHON
|
15.0
|
# Copyright 2012-2018 Therp BV <https://therp.nl>
# Copyright 2018 Brainbean Apps <https://brainbeanapps.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from logging import getLogger
from string import Template
from odoo import api, models
_logger = getLogger(__name__)
class ResCompanyLdapOperator(models.AbstractModel):
"""Define operators for group mappings"""
_name = "res.company.ldap.operator"
_description = "Definition op LDAP operations"
@api.model
def operators(self):
"""Return names of function to call on this model as operator"""
return ("contains", "equals", "query")
def contains(self, ldap_entry, mapping):
return mapping.ldap_attribute in ldap_entry[1] and mapping.value in map(
lambda x: x.decode(), ldap_entry[1][mapping.ldap_attribute]
)
def equals(self, ldap_entry, mapping):
return mapping.ldap_attribute in ldap_entry[1] and mapping.value == str(
list(map(lambda x: x.decode(), ldap_entry[1][mapping.ldap_attribute]))
)
def query(self, ldap_entry, mapping):
query_string = Template(mapping.value).safe_substitute(
{attr: ldap_entry[1][attr][0].decode() for attr in ldap_entry[1]}
)
results = mapping.ldap_id._query(mapping.ldap_id.read()[0], query_string)
_logger.debug('Performed LDAP query "%s" results: %s', query_string, results)
return bool(results)
| 35.926829 | 1,473 |
1,348 |
py
|
PYTHON
|
15.0
|
# Copyright 2012-2018 Therp BV <https://therp.nl>
# Copyright 2018 Brainbean Apps <https://brainbeanapps.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class ResCompanyLdapGroupMapping(models.Model):
_name = "res.company.ldap.group_mapping"
_description = "LDAP group mapping"
_rec_name = "ldap_attribute"
_order = "ldap_attribute"
ldap_id = fields.Many2one(
"res.company.ldap",
"LDAP server",
required=True,
ondelete="cascade",
)
ldap_attribute = fields.Char(
"LDAP attribute",
help=("The LDAP attribute to check.\nFor active directory, use memberOf."),
)
operator = fields.Selection(
lambda self: [
(o, o) for o in self.env["res.company.ldap.operator"].operators()
],
help=(
"The operator to check the attribute against the value\n"
"For active directory, use 'contains'"
),
required=True,
)
value = fields.Char(
help=(
"The value to check the attribute against.\n"
"For active directory, use the dn of the desired group"
),
required=True,
)
group_id = fields.Many2one(
"res.groups", "Odoo group", help="The Odoo group to assign", required=True
)
| 32.095238 | 1,348 |
1,158 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Therp BV <https://therp.nl>
# Copyright 2018 Brainbean Apps <https://brainbeanapps.com>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import SUPERUSER_ID, api, models, registry
class ResUsers(models.Model):
_inherit = "res.users"
@classmethod
def _login(cls, db, login, password, user_agent_env):
user_id = super()._login(db, login, password, user_agent_env)
if not user_id:
return user_id
with registry(db).cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, {})
user = env["res.users"].browse(user_id)
# check if this user came from ldap, rerun get_or_create_user in
# this case to apply ldap groups if necessary
ldaps = user.company_id.ldaps
if user.active and any(ldaps.mapped("only_ldap_groups")):
for conf in ldaps._get_ldap_dicts():
entry = ldaps._authenticate(conf, login, password)
if entry:
ldaps._get_or_create_user(conf, login, entry)
break
return user_id
| 42.888889 | 1,158 |
2,638 |
py
|
PYTHON
|
15.0
|
# Copyright 2012-2018 Therp BV <https://therp.nl>
# Copyright 2018 Brainbean Apps <https://brainbeanapps.com>
# Copyright 2021 Tecnativa - João Marques
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from logging import getLogger
from odoo import _, api, fields, models
from odoo.exceptions import UserError
_logger = getLogger(__name__)
class ResCompanyLdap(models.Model):
_inherit = "res.company.ldap"
group_mapping_ids = fields.One2many(
"res.company.ldap.group_mapping",
"ldap_id",
"Group mappings",
help="Define how Odoo groups are assigned to LDAP users",
)
only_ldap_groups = fields.Boolean(
"Only LDAP groups",
default=False,
help=(
"If this is checked, manual changes to group membership are "
"undone on every login (so Odoo groups are always synchronous "
"with LDAP groups). If not, manually added groups are preserved."
),
)
@api.model
def _get_or_create_user(self, conf, login, ldap_entry):
op_obj = self.env["res.company.ldap.operator"]
user_id = super()._get_or_create_user(conf, login, ldap_entry)
if not user_id:
return user_id
this = self.browse(conf["id"])
SudoUser = self.env["res.users"].sudo().with_context(no_reset_password=True)
user = SudoUser.browse(user_id)
essential_groups = [
self.env.ref("base.group_user").id,
self.env.ref("base.group_portal").id,
self.env.ref("base.group_public").id,
]
groups = []
if this.only_ldap_groups:
_logger.debug("deleting all groups from user %d", user_id)
groups.append((5, False, False))
for mapping in this.group_mapping_ids:
operator = getattr(op_obj, mapping.operator)
_logger.debug("checking mapping %s", mapping)
if operator(ldap_entry, mapping):
_logger.debug(
"adding user %d to group %s",
user,
mapping.group_id.name,
)
groups.append((4, mapping.group_id.id, False))
if (
this.only_ldap_groups
and len([g[1] for g in groups if g[0] == 4 and g[1] in essential_groups])
!= 1
):
raise UserError(
_(
"The created user needs to have one (and only one) of the"
" 'User types /' groups defined."
)
)
user.write({"groups_id": groups})
return user_id
| 36.625 | 2,637 |
735 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ICTSTUDIO <http://www.ictstudio.eu>
# Copyright 2021 ACSONE SA/NV <https://acsone.eu>
# License: AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
{
"name": "Authentication OpenID Connect",
"version": "15.0.1.0.1",
"license": "AGPL-3",
"author": (
"ICTSTUDIO, André Schenkels, "
"ACSONE SA/NV, "
"Odoo Community Association (OCA)"
),
"maintainers": ["sbidoul"],
"website": "https://github.com/OCA/server-auth",
"summary": "Allow users to login through OpenID Connect Provider",
"external_dependencies": {"python": ["python-jose"]},
"depends": ["auth_oauth"],
"data": ["views/auth_oauth_provider.xml"],
"demo": ["demo/local_keycloak.xml"],
}
| 34.952381 | 734 |
2,064 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV <https://acsone.eu>
# License: AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import contextlib
from urllib.parse import parse_qs, urlparse
import odoo
from odoo.tests import common
from odoo.addons.website.tools import MockRequest as _MockRequest
from ..controllers.main import OpenIDLogin
BASE_URL = "http://localhost:%s" % odoo.tools.config["http_port"]
@contextlib.contextmanager
def MockRequest(env):
with _MockRequest(env) as request:
request.httprequest.url_root = BASE_URL + "/"
request.params = {}
yield request
class TestAuthOIDCAuthorizationCodeFlow(common.HttpCase):
def setUp(self):
super().setUp()
# search our test provider and bind the demo user to it
self.provider_rec = self.env["auth.oauth.provider"].search(
[("client_id", "=", "auth_oidc-test")]
)
self.assertEqual(len(self.provider_rec), 1)
def test_auth_link(self):
"""Test that the authentication link is correct."""
# disable existing providers except our test provider
self.env["auth.oauth.provider"].search(
[("client_id", "!=", "auth_oidc-test")]
).write(dict(enabled=False))
with MockRequest(self.env):
providers = OpenIDLogin().list_providers()
self.assertEqual(len(providers), 1)
auth_link = providers[0]["auth_link"]
assert auth_link.startswith(self.provider_rec.auth_endpoint)
params = parse_qs(urlparse(auth_link).query)
self.assertEqual(params["response_type"], ["code"])
self.assertEqual(params["client_id"], [self.provider_rec.client_id])
self.assertEqual(params["scope"], ["openid email"])
self.assertTrue(params["code_challenge"])
self.assertEqual(params["code_challenge_method"], ["S256"])
self.assertTrue(params["nonce"])
self.assertTrue(params["state"])
self.assertEqual(params["redirect_uri"], [BASE_URL + "/auth_oauth/signin"])
| 38.943396 | 2,064 |
2,656 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ICTSTUDIO <http://www.ictstudio.eu>
# Copyright 2021 ACSONE SA/NV <https://acsone.eu>
# License: AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import logging
import secrets
import requests
from odoo import fields, models, tools
try:
from jose import jwt
except ImportError:
logging.getLogger(__name__).debug("jose library not installed")
class AuthOauthProvider(models.Model):
_inherit = "auth.oauth.provider"
flow = fields.Selection(
[
("access_token", "OAuth2"),
("id_token_code", "OpenID Connect (authorization code flow)"),
("id_token", "OpenID Connect (implicit flow, not recommended)"),
],
string="Auth Flow",
required=True,
default="access_token",
)
token_map = fields.Char(
help="Some Oauth providers don't map keys in their responses "
"exactly as required. It is important to ensure user_id and "
"email at least are mapped. For OpenID Connect user_id is "
"the sub key in the standard."
)
client_secret = fields.Char(
help="Used in OpenID Connect authorization code flow for confidential clients.",
)
code_verifier = fields.Char(
default=lambda self: secrets.token_urlsafe(32), help="Used for PKCE."
)
validation_endpoint = fields.Char(required=False)
token_endpoint = fields.Char(
string="Token URL", help="Required for OpenID Connect authorization code flow."
)
jwks_uri = fields.Char(string="JWKS URL", help="Required for OpenID Connect.")
@tools.ormcache("self.jwks_uri", "kid")
def _get_key(self, kid):
r = requests.get(self.jwks_uri)
r.raise_for_status()
response = r.json()
for key in response["keys"]:
if key["kid"] == kid:
return key
return {}
def _map_token_values(self, res):
if self.token_map:
for pair in self.token_map.split(" "):
from_key, to_key = [k.strip() for k in pair.split(":", 1)]
if to_key not in res:
res[to_key] = res.get(from_key, "")
return res
def _parse_id_token(self, id_token, access_token):
self.ensure_one()
res = {}
header = jwt.get_unverified_header(id_token)
res.update(
jwt.decode(
id_token,
self._get_key(header.get("kid")),
algorithms=["RS256"],
audience=self.client_id,
access_token=access_token,
)
)
res.update(self._map_token_values(res))
return res
| 32.390244 | 2,656 |
3,061 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ICTSTUDIO <http://www.ictstudio.eu>
# Copyright 2021 ACSONE SA/NV <https://acsone.eu>
# License: AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import logging
import requests
from odoo import api, models
from odoo.exceptions import AccessDenied
from odoo.http import request
_logger = logging.getLogger(__name__)
class ResUsers(models.Model):
_inherit = "res.users"
def _auth_oauth_get_tokens_implicit_flow(self, oauth_provider, params):
# https://openid.net/specs/openid-connect-core-1_0.html#ImplicitAuthResponse
return params.get("access_token"), params.get("id_token")
def _auth_oauth_get_tokens_auth_code_flow(self, oauth_provider, params):
# https://openid.net/specs/openid-connect-core-1_0.html#AuthResponse
code = params.get("code")
# https://openid.net/specs/openid-connect-core-1_0.html#TokenRequest
auth = None
if oauth_provider.client_secret:
auth = (oauth_provider.client_id, oauth_provider.client_secret)
response = requests.post(
oauth_provider.token_endpoint,
data=dict(
client_id=oauth_provider.client_id,
grant_type="authorization_code",
code=code,
code_verifier=oauth_provider.code_verifier, # PKCE
redirect_uri=request.httprequest.url_root + "auth_oauth/signin",
),
auth=auth,
)
response.raise_for_status()
response_json = response.json()
# https://openid.net/specs/openid-connect-core-1_0.html#TokenResponse
return response_json.get("access_token"), response_json.get("id_token")
@api.model
def auth_oauth(self, provider, params):
oauth_provider = self.env["auth.oauth.provider"].browse(provider)
if oauth_provider.flow == "id_token":
access_token, id_token = self._auth_oauth_get_tokens_implicit_flow(
oauth_provider, params
)
elif oauth_provider.flow == "id_token_code":
access_token, id_token = self._auth_oauth_get_tokens_auth_code_flow(
oauth_provider, params
)
else:
return super(ResUsers, self).auth_oauth(provider, params)
if not access_token:
_logger.error("No access_token in response.")
raise AccessDenied()
if not id_token:
_logger.error("No id_token in response.")
raise AccessDenied()
validation = oauth_provider._parse_id_token(id_token, access_token)
# required check
if not validation.get("user_id"):
_logger.error("user_id claim not found in id_token (after mapping).")
raise AccessDenied()
# retrieve and sign in user
params["access_token"] = access_token
login = self._auth_oauth_signin(provider, validation, params)
if not login:
raise AccessDenied()
# return user credentials
return (self.env.cr.dbname, login, access_token)
| 40.276316 | 3,061 |
2,119 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ICTSTUDIO <http://www.ictstudio.eu>
# Copyright 2021 ACSONE SA/NV <https://acsone.eu>
# License: AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import base64
import hashlib
import logging
import secrets
from werkzeug.urls import url_decode, url_encode
from odoo.addons.auth_oauth.controllers.main import OAuthLogin
_logger = logging.getLogger(__name__)
class OpenIDLogin(OAuthLogin):
def list_providers(self):
providers = super(OpenIDLogin, self).list_providers()
for provider in providers:
flow = provider.get("flow")
if flow in ("id_token", "id_token_code"):
params = url_decode(provider["auth_link"].split("?")[-1])
# nonce
params["nonce"] = secrets.token_urlsafe()
# response_type
if flow == "id_token":
# https://openid.net/specs/openid-connect-core-1_0.html
# #ImplicitAuthRequest
params["response_type"] = "id_token token"
elif flow == "id_token_code":
# https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest
params["response_type"] = "code"
# PKCE (https://tools.ietf.org/html/rfc7636)
code_verifier = provider["code_verifier"]
code_challenge = base64.urlsafe_b64encode(
hashlib.sha256(code_verifier.encode("ascii")).digest()
).rstrip(b"=")
params["code_challenge"] = code_challenge
params["code_challenge_method"] = "S256"
# scope
if provider.get("scope"):
if "openid" not in provider["scope"].split():
_logger.error("openid connect scope must contain 'openid'")
params["scope"] = provider["scope"]
# auth link that the user will click
provider["auth_link"] = "{}?{}".format(
provider["auth_endpoint"], url_encode(params)
)
return providers
| 42.38 | 2,119 |
756 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Auth API key server environment",
"summary": """
Configure api keys via server env.
This can be very useful to avoid mixing your keys between your various
environments when restoring databases. All you have to do is to add a new
section to your configuration file according to the following convention:
""",
"version": "15.0.1.0.0",
"development_status": "Alpha",
"license": "LGPL-3",
"website": "https://github.com/OCA/server-auth",
"author": "Camptocamp,Odoo Community Association (OCA)",
"depends": ["auth_api_key", "server_environment"],
"data": [],
}
| 36 | 756 |
1,298 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# Copyright 2021 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
from odoo.addons.server_environment import serv_config
class TestAuthApiKey(TransactionCase):
@classmethod
def setUpClass(cls, *args, **kwargs):
super().setUpClass(*args, **kwargs)
cls.AuthApiKey = cls.env["auth.api.key"]
cls.demo_user = cls.env.ref("base.user_demo")
cls.api_key_from_env = cls.AuthApiKey.create(
{"name": "from_env", "key": "dummy", "user_id": cls.demo_user.id}
)
cls.api_key_from_env.refresh()
serv_config.add_section("api_key_from_env")
serv_config.set("api_key_from_env", "key", "api_key_from_env")
def test_lookup_key_from_env(self):
self.assertEqual(
self.env["auth.api.key"]._retrieve_uid_from_api_key("api_key_from_env"),
self.demo_user.id,
)
with self.assertRaises(ValidationError):
# dummy key must be replace with the one from env and
# therefore should be unusable
self.env["auth.api.key"]._retrieve_uid_from_api_key("dummy")
| 40.5625 | 1,298 |
945 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# Copyright 2021 Camptocamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import models
class AuthApiKey(models.Model):
_name = "auth.api.key"
_inherit = ["auth.api.key", "server.env.mixin"]
def _server_env_section_name(self):
"""Name of the section in the configuration files
We override the default implementation to keep the compatibility
with the previous implementation of auth_api_key. The section name
into the configuration file must be formatted as
'api_key_{name}'
"""
self.ensure_one()
return "api_key_{}".format(self.name)
@property
def _server_env_fields(self):
base_fields = super()._server_env_fields
api_key_fields = {"key": {}}
api_key_fields.update(base_fields)
return api_key_fields
| 28.636364 | 945 |
626 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antiun Ingeniería, S.L.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Verify email at signup",
"summary": "Force uninvited users to use a good email for signup",
"version": "15.0.1.0.0",
"category": "Authentication",
"website": "https://github.com/OCA/server-auth",
"author": "Antiun Ingeniería S.L., "
"Tecnativa, "
"Odoo Community Association (OCA)",
"license": "AGPL-3",
"depends": ["auth_signup"],
"external_dependencies": {"python": ["lxml", "email_validator"]},
"data": ["views/signup.xml"],
"installable": True,
}
| 36.705882 | 624 |
1,889 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Jairo Llopis <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from lxml.html import document_fromstring
from mock import patch
from odoo.tests.common import HttpCase
from odoo.tools.misc import mute_logger
from odoo.addons.mail.models import mail_template
class UICase(HttpCase):
def setUp(self):
super().setUp()
if "website" in self.env:
# Enable public signup in website if it is installed; otherwise
# tests here would fail
current_website = self.env["website"].get_current_website()
current_website.auth_signup_uninvited = "b2c"
self.env["ir.config_parameter"].set_param("auth_signup.invitation_scope", "b2c")
self.data = {
"csrf_token": self.csrf_token(),
"name": "Somebody",
}
def html_doc(self, url="/web/signup", data=None, timeout=30):
"""Get an HTML LXML document."""
with patch(mail_template.__name__ + ".MailTemplate.send_mail"):
resp = self.url_open(url, data=data, timeout=timeout)
return document_fromstring(resp.content)
def csrf_token(self):
"""Get a valid CSRF token."""
doc = self.html_doc()
return doc.xpath("//input[@name='csrf_token']")[0].get("value")
def test_bad_email(self):
"""Test rejection of bad emails."""
self.data["login"] = "bad email"
doc = self.html_doc(data=self.data)
self.assertTrue(doc.xpath('//p[@class="alert alert-danger"]'))
@mute_logger("odoo.addons.auth_signup_verify_email.controllers.main")
def test_good_email(self):
"""Test acceptance of good emails."""
self.data["login"] = "[email protected]"
doc = self.html_doc(data=self.data)
self.assertTrue(doc.xpath('//p[@class="alert alert-success"]'))
| 38.55102 | 1,889 |
2,969 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Antiun Ingeniería, S.L.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
from email_validator import EmailSyntaxError, EmailUndeliverableError, validate_email
from odoo import _
from odoo.http import request, route
from odoo.addons.auth_signup.controllers.main import AuthSignupHome
_logger = logging.getLogger(__name__)
class SignupVerifyEmail(AuthSignupHome):
@route()
def web_auth_signup(self, *args, **kw):
if request.params.get("login") and not request.params.get("password"):
return self.passwordless_signup()
return super().web_auth_signup(*args, **kw)
def passwordless_signup(self):
values = request.params
qcontext = self.get_auth_signup_qcontext()
# Check good format of e-mail
try:
validate_email(values.get("login", ""))
except EmailSyntaxError as error:
qcontext["error"] = getattr(
error,
"message",
_("That does not seem to be an email address."),
)
return request.render("auth_signup.signup", qcontext)
except EmailUndeliverableError as error:
qcontext["error"] = str(error)
return request.render("auth_signup.signup", qcontext)
except Exception as error:
qcontext["error"] = str(error)
return request.render("auth_signup.signup", qcontext)
if not values.get("email"):
values["email"] = values.get("login")
# preserve user lang
values["lang"] = request.context.get("lang", "")
# remove values that could raise "Invalid field '*' on model 'res.users'"
values.pop("redirect", "")
values.pop("token", "")
# Remove password
values["password"] = ""
sudo_users = request.env["res.users"].with_context(create_user=True).sudo()
try:
with request.cr.savepoint():
sudo_users.signup(values, qcontext.get("token"))
sudo_users.reset_password(values.get("login"))
except Exception as error:
# Duplicate key or wrong SMTP settings, probably
_logger.exception(error)
if (
request.env["res.users"]
.sudo()
.search([("login", "=", qcontext.get("login"))])
):
qcontext["error"] = _(
"Another user is already registered using this email" " address."
)
else:
# Agnostic message for security
qcontext["error"] = _(
"Something went wrong, please try again later or" " contact us."
)
return request.render("auth_signup.signup", qcontext)
qcontext["message"] = _("Check your email to activate your account!")
return request.render("auth_signup.reset_password", qcontext)
| 37.1 | 2,968 |
477 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Auth Api Key",
"summary": """
Authenticate http requests from an API key""",
"version": "15.0.1.1.1",
"license": "LGPL-3",
"author": "ACSONE SA/NV,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-auth",
"development_status": "Beta",
"data": ["security/ir.model.access.csv", "views/auth_api_key.xml"],
}
| 34.071429 | 477 |
1,788 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.exceptions import AccessError, ValidationError
from odoo.tests.common import TransactionCase
class TestAuthApiKey(TransactionCase):
@classmethod
def setUpClass(cls, *args, **kwargs):
super().setUpClass(*args, **kwargs)
cls.AuthApiKey = cls.env["auth.api.key"]
cls.demo_user = cls.env.ref("base.user_demo")
cls.api_key_good = cls.AuthApiKey.create(
{"name": "good", "user_id": cls.demo_user.id, "key": "api_key"}
)
def test_lookup_key_from_db(self):
demo_user = self.env.ref("base.user_demo")
self.assertEqual(
self.env["auth.api.key"]._retrieve_uid_from_api_key("api_key"), demo_user.id
)
def test_wrong_key(self):
with self.assertRaises(ValidationError), self.env.cr.savepoint():
self.env["auth.api.key"]._retrieve_uid_from_api_key("api_wrong_key")
def test_user_not_allowed(self):
# only system users can check for key
with self.assertRaises(AccessError), self.env.cr.savepoint():
self.env["auth.api.key"].with_user(
user=self.demo_user
)._retrieve_uid_from_api_key("api_wrong_key")
def test_cache_invalidation(self):
self.assertEqual(
self.env["auth.api.key"]._retrieve_uid_from_api_key("api_key"),
self.demo_user.id,
)
self.api_key_good.write({"key": "updated_key"})
self.assertEqual(
self.env["auth.api.key"]._retrieve_uid_from_api_key("updated_key"),
self.demo_user.id,
)
with self.assertRaises(ValidationError):
self.env["auth.api.key"]._retrieve_uid_from_api_key("api_key")
| 39.733333 | 1,788 |
1,265 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# Copyright 2017 Akretion (http://www.akretion.com).
# @author Sébastien BEAU <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from odoo import models
from odoo.exceptions import AccessDenied
from odoo.http import request
_logger = logging.getLogger(__name__)
class IrHttp(models.AbstractModel):
_inherit = "ir.http"
@classmethod
def _auth_method_api_key(cls):
headers = request.httprequest.environ
api_key = headers.get("HTTP_API_KEY")
if api_key:
request.uid = 1
auth_api_key = request.env["auth.api.key"]._retrieve_api_key(api_key)
if auth_api_key:
# reset _env on the request since we change the uid...
# the next call to env will instantiate an new
# odoo.api.Environment with the user defined on the
# auth.api_key
request._env = None
request.uid = auth_api_key.user_id.id
request.auth_api_key = api_key
request.auth_api_key_id = auth_api_key.id
return True
_logger.error("Wrong HTTP_API_KEY, access denied")
raise AccessDenied()
| 35.111111 | 1,264 |
2,058 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import _, api, fields, models, tools
from odoo.exceptions import AccessError, ValidationError
from odoo.tools import consteq
class AuthApiKey(models.Model):
_name = "auth.api.key"
_description = "API Key"
name = fields.Char(required=True)
key = fields.Char(
required=True,
help="""The API key. Enter a dummy value in this field if it is
obtained from the server environment configuration.""",
)
user_id = fields.Many2one(
comodel_name="res.users",
string="User",
required=True,
help="""The user used to process the requests authenticated by
the api key""",
)
_sql_constraints = [("name_uniq", "unique(name)", "Api Key name must be unique.")]
@api.model
def _retrieve_api_key(self, key):
return self.browse(self._retrieve_api_key_id(key))
@api.model
@tools.ormcache("key")
def _retrieve_api_key_id(self, key):
if not self.env.user.has_group("base.group_system"):
raise AccessError(_("User is not allowed"))
for api_key in self.search([]):
if api_key.key and consteq(key, api_key.key):
return api_key.id
raise ValidationError(_("The key %s is not allowed") % key)
@api.model
@tools.ormcache("key")
def _retrieve_uid_from_api_key(self, key):
return self._retrieve_api_key(key).user_id.id
def _clear_key_cache(self):
self._retrieve_api_key_id.clear_cache(self.env[self._name])
self._retrieve_uid_from_api_key.clear_cache(self.env[self._name])
@api.model
def create(self, vals):
record = super(AuthApiKey, self).create(vals)
if "key" in vals or "user_id" in vals:
self._clear_key_cache()
return record
def write(self, vals):
super(AuthApiKey, self).write(vals)
if "key" in vals or "user_id" in vals:
self._clear_key_cache()
return True
| 32.666667 | 2,058 |
1,318 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-server-auth",
description="Meta package for oca-server-auth Odoo addons",
version=version,
install_requires=[
'odoo-addon-auth_admin_passkey>=15.0dev,<15.1dev',
'odoo-addon-auth_api_key>=15.0dev,<15.1dev',
'odoo-addon-auth_api_key_group>=15.0dev,<15.1dev',
'odoo-addon-auth_api_key_server_env>=15.0dev,<15.1dev',
'odoo-addon-auth_ldaps>=15.0dev,<15.1dev',
'odoo-addon-auth_oauth_multi_token>=15.0dev,<15.1dev',
'odoo-addon-auth_oidc>=15.0dev,<15.1dev',
'odoo-addon-auth_saml>=15.0dev,<15.1dev',
'odoo-addon-auth_session_timeout>=15.0dev,<15.1dev',
'odoo-addon-auth_signup_partner_company>=15.0dev,<15.1dev',
'odoo-addon-auth_signup_verify_email>=15.0dev,<15.1dev',
'odoo-addon-auth_user_case_insensitive>=15.0dev,<15.1dev',
'odoo-addon-password_security>=15.0dev,<15.1dev',
'odoo-addon-users_ldap_groups>=15.0dev,<15.1dev',
'odoo-addon-vault>=15.0dev,<15.1dev',
'odoo-addon-vault_share>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 39.939394 | 1,318 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=["setuptools-odoo"],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
808 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptcamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Auth API key group",
"summary": """
Allow grouping API keys together.
Grouping per se does nothing. This feature is supposed to be used by other modules
to limit access to services or records based on groups of keys.
""",
"version": "15.0.1.0.0",
"development_status": "Alpha",
"license": "LGPL-3",
"website": "https://github.com/OCA/server-auth",
"author": "Camptcamp,Odoo Community Association (OCA)",
"maintainers": ["simahawk"],
"depends": ["auth_api_key"],
"data": [
"security/ir.model.access.csv",
"views/auth_api_key_view.xml",
"views/auth_api_key_group_view.xml",
],
}
| 32.32 | 808 |
1,879 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptcamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo.tests.common import TransactionCase
class TestAuthApiKey(TransactionCase):
@classmethod
def setUpClass(cls, *args, **kwargs):
super().setUpClass(*args, **kwargs)
cls.AuthApiKey = cls.env["auth.api.key"]
cls.AuthApiKeyGroup = cls.env["auth.api.key.group"]
cls.demo_user = cls.env.ref("base.user_demo")
cls.api_key1 = cls.AuthApiKey.create(
{"name": "One", "user_id": cls.demo_user.id, "key": "one"}
)
cls.api_key2 = cls.AuthApiKey.create(
{"name": "Two", "user_id": cls.demo_user.id, "key": "two"}
)
cls.api_key3 = cls.AuthApiKey.create(
{"name": "Three", "user_id": cls.demo_user.id, "key": "three"}
)
cls.api_key_group1 = cls.AuthApiKeyGroup.create(
{
"name": "G One",
"code": "g-one",
"auth_api_key_ids": [(6, 0, (cls.api_key1 + cls.api_key2).ids)],
}
)
cls.api_key_group2 = cls.AuthApiKeyGroup.create(
{
"name": "G Two",
"code": "g-two",
"auth_api_key_ids": [(6, 0, cls.api_key3.ids)],
}
)
def test_relations(self):
self.assertIn(self.api_key_group1, self.api_key1.auth_api_key_group_ids)
self.assertIn(self.api_key_group1, self.api_key2.auth_api_key_group_ids)
self.assertNotIn(self.api_key_group1, self.api_key3.auth_api_key_group_ids)
self.assertIn(self.api_key_group2, self.api_key3.auth_api_key_group_ids)
self.assertNotIn(self.api_key_group2, self.api_key1.auth_api_key_group_ids)
self.assertNotIn(self.api_key_group2, self.api_key1.auth_api_key_group_ids)
| 40.847826 | 1,879 |
613 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptcamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class AuthApiKeyGroup(models.Model):
"""Group API keys together."""
_name = "auth.api.key.group"
_description = "API Key auth group"
name = fields.Char(required=True)
code = fields.Char(required=True)
auth_api_key_ids = fields.Many2many(
comodel_name="auth.api.key",
relation="auth_api_key_group_rel",
column1="group_id",
column2="key_id",
string="API Keys",
)
| 26.652174 | 613 |
469 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Camptcamp SA
# @author: Simone Orsi <[email protected]>
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import fields, models
class AuthApiKey(models.Model):
_inherit = "auth.api.key"
auth_api_key_group_ids = fields.Many2many(
comodel_name="auth.api.key.group",
relation="auth_api_key_group_rel",
column1="key_id",
column2="group_id",
string="Auth Groups",
)
| 24.684211 | 469 |
646 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Florent de Labarre
# Copyright 2017 Camptocamp
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
{
"name": "OAuth Multi Token",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Florent de Labarre, Camptocamp, Odoo Community Association (OCA)",
"summary": """Allow multiple connection with the same OAuth account""",
"category": "Tool",
"website": "https://github.com/OCA/server-auth",
"depends": ["auth_oauth"],
"data": [
"security/ir.model.access.csv",
"views/auth_oauth_multi_token.xml",
"views/res_users.xml",
],
"installable": True,
}
| 32.3 | 646 |
3,143 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Camptocamp
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import json
from odoo import exceptions
from odoo.tests import TransactionCase
class TestMultiToken(TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.token_model = cls.env["auth.oauth.multi.token"]
cls.provider_google = cls.env.ref("auth_oauth.provider_google")
cls.user_model = cls.env["res.users"].with_context(
tracking_disable=True, no_reset_password=True
)
cls.user = cls.user_model.create(
{
"name": "John Doe",
"login": "johndoe",
"oauth_uid": "oauth_uid_johndoe",
"oauth_provider_id": cls.provider_google.id,
}
)
def _fake_params(self, **kw):
params = {
"state": json.dumps({"t": "FAKE_TOKEN"}),
"access_token": "FAKE_ACCESS_TOKEN",
}
params.update(kw)
return params
def test_no_provider_no_access(self):
validation = {
"user_id": "oauth_uid_no_one",
}
params = self._fake_params()
with self.assertRaises(exceptions.AccessDenied):
self.user_model._auth_oauth_signin(
self.provider_google.id, validation, params
)
def _test_one_token(self):
validation = {
"user_id": "oauth_uid_johndoe",
}
params = self._fake_params()
login = self.user_model._auth_oauth_signin(
self.provider_google.id, validation, params
)
self.assertEqual(login, "johndoe")
def test_access_one_token(self):
# no token yet
self.assertFalse(self.user.oauth_access_token_ids)
self._test_one_token()
token_count = 1
self.assertEqual(len(self.user.oauth_access_token_ids), token_count)
self.assertEqual(
len(self.token_model._oauth_user_tokens(self.user.id)), token_count
)
def test_access_multi_token(self):
# no token yet
self.assertFalse(self.user.oauth_access_token_ids)
# use as many token as max allowed
for token_count in range(1, self.user.oauth_access_max_token + 1):
self._test_one_token()
self.assertEqual(len(self.user.oauth_access_token_ids), token_count)
self.assertEqual(
len(self.token_model._oauth_user_tokens(self.user.id)), token_count
)
# exceed the number
self._test_one_token()
# token count does not exceed max number
self.assertEqual(
len(self.user.oauth_access_token_ids), self.user.oauth_access_max_token
)
def test_remove_oauth_access_token(self):
res = self.user._get_session_token_fields()
self.assertFalse("oauth_access_token" in res)
self.assertTrue("oauth_master_uuid" in res)
def test_action_oauth_clear_token(self):
self.user.action_oauth_clear_token()
active_token = self.user.oauth_access_token_ids
self.assertEqual(len(active_token), 0)
| 34.538462 | 3,143 |
2,732 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Florent de Labarre
# Copyright 2017 Camptocamp
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
import uuid
from odoo import api, exceptions, fields, models
from odoo.addons import base
base.models.res_users.USER_PRIVATE_FIELDS.append("oauth_master_uuid")
class ResUsers(models.Model):
_inherit = "res.users"
def _generate_oauth_master_uuid(self):
return uuid.uuid4().hex
oauth_access_token_ids = fields.One2many(
comodel_name="auth.oauth.multi.token",
inverse_name="user_id",
string="OAuth tokens",
copy=False,
readonly=True,
groups="base.group_system",
)
oauth_access_max_token = fields.Integer(
string="Max number of simultaneous connections", default=10, required=True
)
oauth_master_uuid = fields.Char(
string="Master UUID",
copy=False,
readonly=True,
required=True,
default=lambda self: self._generate_oauth_master_uuid(),
)
@property
def multi_token_model(self):
return self.env["auth.oauth.multi.token"]
@api.model
def _auth_oauth_signin(self, provider, validation, params):
"""Override to handle sign-in with multi token."""
res = super()._auth_oauth_signin(provider, validation, params)
oauth_uid = validation["user_id"]
# Lookup for user by oauth uid and provider
user = self.search(
[("oauth_uid", "=", oauth_uid), ("oauth_provider_id", "=", provider)]
)
if not user:
raise exceptions.AccessDenied()
user.ensure_one()
# user found and unique: create a token
self.multi_token_model.create(
{"user_id": user.id, "oauth_access_token": params["access_token"]}
)
return res
def action_oauth_clear_token(self):
"""Inactivate current user tokens."""
self.mapped("oauth_access_token_ids")._oauth_clear_token()
for res in self:
res.oauth_access_token = False
res.oauth_master_uuid = self._generate_oauth_master_uuid()
@api.model
def _check_credentials(self, password, env):
"""Override to check credentials against multi tokens."""
try:
return super()._check_credentials(password, env)
except exceptions.AccessDenied:
res = self.multi_token_model.sudo().search(
[("user_id", "=", self.env.uid), ("oauth_access_token", "=", password)]
)
if not res:
raise
def _get_session_token_fields(self):
res = super()._get_session_token_fields()
res.remove("oauth_access_token")
return res | {"oauth_master_uuid"}
| 32.915663 | 2,732 |
1,559 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Florent de Labarre
# Copyright 2017 Camptocamp
# Copyright 2021 ACSONE SA/NV
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl)
from odoo import api, fields, models
class AuthOauthMultiToken(models.Model):
"""Define a set of tokens."""
_name = "auth.oauth.multi.token"
_description = "OAuth2 token"
_order = "id desc"
oauth_access_token = fields.Char(
string="OAuth Access Token", readonly=True, copy=False
)
user_id = fields.Many2one(
comodel_name="res.users",
string="User",
required=True,
readonly=True,
index=True,
ondelete="cascade",
)
@api.model
def create(self, vals):
"""Override to validate tokens."""
token = super().create(vals)
token._oauth_validate_multi_token()
return token
@api.model
def _oauth_user_tokens(self, user_id):
"""Retrieve tokens for given user.
:param user_id: Odoo ID of the user
"""
return self.search([("user_id", "=", user_id)])
def _oauth_validate_multi_token(self):
"""Check current user's token and clear them if max number reached."""
user_tokens = self._oauth_user_tokens(self.user_id.id)
max_token = self.user_id.oauth_access_max_token
if user_tokens and len(user_tokens) > max_token:
# clear last token
user_tokens[max_token - 1]._oauth_clear_token()
def _oauth_clear_token(self):
"""Disable current token records."""
self.unlink()
| 29.415094 | 1,559 |
378 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Quartile Limited
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Auth Signup Partner Company",
"version": "15.0.1.0.0",
"author": "Quartile Limited, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-auth",
"depends": ["auth_signup"],
"license": "AGPL-3",
"installable": True,
}
| 34.363636 | 378 |
1,359 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Quartile Limited
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo.tests.common import TransactionCase
class TestAuthSignupPartnerCompany(TransactionCase):
def setUp(self):
super(TestAuthSignupPartnerCompany, self).setUp()
self.env["ir.config_parameter"].set_param("auth_signup.invitation_scope", "b2c")
self.company_1 = self.env.company
self.company_2 = self.env["res.company"].create({"name": "company 2"})
def test_auth_signup_company(self):
self.assertEqual(self.env.company, self.company_1)
self.env["res.users"].signup(
{"name": "test 1", "login": "[email protected]", "password": "12345678"}
)
user = self.env["res.users"].search([("login", "=", "[email protected]")])
self.assertEqual(user.company_id, self.company_1)
self.assertEqual(user.partner_id.company_id, self.company_1)
# Switch to another company and sign up.
self.env.company = self.company_2
self.env["res.users"].signup(
{"name": "test 2", "login": "[email protected]", "password": "12345678"}
)
user = self.env["res.users"].search([("login", "=", "[email protected]")])
self.assertEqual(user.company_id, self.company_2)
self.assertEqual(user.partner_id.company_id, self.company_2)
| 46.862069 | 1,359 |
566 |
py
|
PYTHON
|
15.0
|
# Copyright 2023 Quartile Limited
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
from odoo import models
class ResUsers(models.Model):
_inherit = "res.users"
def _create_user_from_template(self, values):
values["company_ids"] = [self.env.company.id]
values["company_id"] = self.env.company.id
return super()._create_user_from_template(values)
def _signup_create_user(self, values):
user = super()._signup_create_user(values)
user.partner_id.company_id = self.env.company
return user
| 31.444444 | 566 |
701 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2017 Creu Blanca
# Copyright (C) 2018 Brainbean Apps
# Copyright 2020 CorporateHub (https://corporatehub.eu)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "LDAPS authentication",
"version": "15.0.1.0.0",
"category": "Tools",
"website": "https://github.com/OCA/server-auth",
"author": "CorporateHub, " "Creu Blanca, " "Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"application": False,
"summary": "Allows to use LDAP over SSL authentication",
"depends": ["auth_ldap"],
"data": ["views/res_company_ldap_views.xml"],
"external_dependencies": {"python": ["python-ldap"]},
}
| 36.894737 | 701 |
1,912 |
py
|
PYTHON
|
15.0
|
# Copyright (C) Creu Blanca
# Copyright (C) 2018 Brainbean Apps
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
import logging
import ldap
from odoo import fields, models
_logger = logging.getLogger(__name__)
class CompanyLDAP(models.Model):
_inherit = "res.company.ldap"
_description = "Company LDAP configuration"
is_ssl = fields.Boolean(string="Use LDAPS", default=False)
skip_cert_validation = fields.Boolean(
string="Skip certificate validation", default=False
)
def _get_ldap_dicts(self):
res = super()._get_ldap_dicts()
for rec in res:
ldap = self.sudo().browse(rec["id"])
rec["is_ssl"] = ldap.is_ssl or False
rec["skip_cert_validation"] = ldap.skip_cert_validation or False
return res
def _connect(self, conf):
if conf["is_ssl"]:
uri = "ldaps://%s:%d" % (conf["ldap_server"], conf["ldap_server_port"])
connection = ldap.initialize(uri)
if conf["skip_cert_validation"]:
connection.set_option(ldap.OPT_X_TLS_REQUIRE_CERT, ldap.OPT_X_TLS_ALLOW)
# this creates a new tls context, which is required to apply
# the options, but it also clears the default options defined
# in the openldap's configuration file, such as the TLS_CACERT
# option, which specifies the file containing the trusted
# certificates. this causes certificate verification to fail,
# even if it would succeed with the default options. this is
# why this is only called if we want to skip certificate
# verification.
connection.set_option(ldap.OPT_X_TLS_NEWCTX, 0)
if conf["ldap_tls"]:
connection.start_tls_s()
return connection
return super()._connect(conf)
| 38.24 | 1,912 |
602 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Auth JWT",
"summary": """
JWT bearer token authentication.""",
"version": "14.0.1.2.0",
"license": "LGPL-3",
"author": "ACSONE SA/NV,Odoo Community Association (OCA)",
"maintainers": ["sbidoul"],
"website": "https://github.com/OCA/server-auth",
"depends": [],
"external_dependencies": {"python": ["pyjwt", "cryptography"]},
"data": ["security/ir.model.access.csv", "views/auth_jwt_validator_views.xml"],
"demo": [],
"installable": False,
}
| 33.444444 | 602 |
602 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl)
from werkzeug.exceptions import InternalServerError, Unauthorized
class UnauthorizedMissingAuthorizationHeader(Unauthorized):
pass
class UnauthorizedMalformedAuthorizationHeader(Unauthorized):
pass
class UnauthorizedSessionMismatch(Unauthorized):
pass
class AmbiguousJwtValidator(InternalServerError):
pass
class JwtValidatorNotFound(InternalServerError):
pass
class UnauthorizedInvalidToken(Unauthorized):
pass
class UnauthorizedPartnerNotFound(Unauthorized):
pass
| 18.8125 | 602 |
12,826 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import contextlib
import time
from unittest.mock import Mock
import jwt
import odoo.http
from odoo.exceptions import ValidationError
from odoo.tests.common import TransactionCase
from odoo.tools import mute_logger
from odoo.tools.misc import DotDict
from ..exceptions import (
AmbiguousJwtValidator,
JwtValidatorNotFound,
UnauthorizedInvalidToken,
UnauthorizedMalformedAuthorizationHeader,
UnauthorizedMissingAuthorizationHeader,
UnauthorizedPartnerNotFound,
)
class TestAuthMethod(TransactionCase):
@contextlib.contextmanager
def _mock_request(self, authorization):
environ = {}
if authorization:
environ["HTTP_AUTHORIZATION"] = authorization
request = Mock(
context={},
db=self.env.cr.dbname,
uid=None,
httprequest=Mock(environ=environ),
session=DotDict(),
env=self.env,
)
# These attributes are added upon successful auth, so make sure
# calling hasattr on the mock when they are not yet set returns False.
del request.jwt_payload
del request.jwt_partner_id
with contextlib.ExitStack() as s:
odoo.http._request_stack.push(request)
s.callback(odoo.http._request_stack.pop)
yield request
def _create_token(
self,
key="thesecret",
audience="me",
issuer="http://the.issuer",
exp_delta=100,
nbf=None,
email=None,
):
payload = dict(aud=audience, iss=issuer, exp=time.time() + exp_delta)
if email:
payload["email"] = email
if nbf:
payload["nbf"] = nbf
return jwt.encode(payload, key=key, algorithm="HS256")
def _create_validator(self, name, audience="me", partner_id_required=False):
return self.env["auth.jwt.validator"].create(
dict(
name=name,
signature_type="secret",
secret_algorithm="HS256",
secret_key="thesecret",
audience=audience,
issuer="http://the.issuer",
user_id_strategy="static",
partner_id_strategy="email",
partner_id_required=partner_id_required,
)
)
@contextlib.contextmanager
def _commit_validator(self, name, audience="me", partner_id_required=False):
validator = self._create_validator(
name=name, audience=audience, partner_id_required=partner_id_required
)
def _mocked_get_validator_by_name(self, validator_name):
if validator_name == name:
return validator
return self.env["auth.jwt.validator"]._get_validator_by_name.origin(
self, validator_name
)
try:
# Patch _get_validator_by_name because IrHttp._auth_method_jwt
# will look for the validator in another transaction,
# where the validator we created above would not be visible.
self.env["auth.jwt.validator"]._patch_method(
"_get_validator_by_name", _mocked_get_validator_by_name
)
yield validator
finally:
self.env["auth.jwt.validator"]._revert_method("_get_validator_by_name")
def test_missing_authorization_header(self):
with self._mock_request(authorization=None):
with self.assertRaises(UnauthorizedMissingAuthorizationHeader):
self.env["ir.http"]._auth_method_jwt()
def test_malformed_authorization_header(self):
for authorization in (
"a",
"Bearer",
"Bearer ",
"Bearer x y",
"Bearer token ",
"bearer token",
):
with self._mock_request(authorization=authorization):
with self.assertRaises(UnauthorizedMalformedAuthorizationHeader):
self.env["ir.http"]._auth_method_jwt()
def test_auth_method_valid_token(self):
with self._commit_validator("validator"):
authorization = "Bearer " + self._create_token()
with self._mock_request(authorization=authorization):
self.env["ir.http"]._auth_method_jwt_validator()
def test_auth_method_valid_token_two_validators(self):
with self._commit_validator(
"validator2", audience="bad"
), self._commit_validator("validator3"):
authorization = "Bearer " + self._create_token()
with self._mock_request(authorization=authorization):
# first validator rejects the token because of invalid audience
with self.assertRaises(UnauthorizedInvalidToken):
self.env["ir.http"]._auth_method_jwt_validator2()
# second validator accepts the token
self.env["ir.http"]._auth_method_jwt_validator3()
def test_auth_method_invalid_token(self):
# Test invalid token via _auth_method_jwt
# Other types of invalid tokens are unit tested elswhere.
with self._commit_validator("validator4"):
authorization = "Bearer " + self._create_token(audience="bad")
with self._mock_request(authorization=authorization):
with self.assertRaises(UnauthorizedInvalidToken):
self.env["ir.http"]._auth_method_jwt_validator4()
def test_user_id_strategy(self):
with self._commit_validator("validator5") as validator:
authorization = "Bearer " + self._create_token()
with self._mock_request(authorization=authorization) as request:
self.env["ir.http"]._auth_method_jwt_validator5()
self.assertEqual(request.uid, validator.static_user_id.id)
def test_partner_id_strategy_email_found(self):
partner = self.env["res.partner"].search([("email", "!=", False)])[0]
with self._commit_validator("validator6"):
authorization = "Bearer " + self._create_token(email=partner.email)
with self._mock_request(authorization=authorization) as request:
self.env["ir.http"]._auth_method_jwt_validator6()
self.assertEqual(request.jwt_partner_id, partner.id)
def test_partner_id_strategy_email_not_found(self):
with self._commit_validator("validator6"):
authorization = "Bearer " + self._create_token(
email="[email protected]"
)
with self._mock_request(authorization=authorization) as request:
self.env["ir.http"]._auth_method_jwt_validator6()
self.assertFalse(request.jwt_partner_id)
def test_partner_id_strategy_email_not_found_partner_required(self):
with self._commit_validator("validator6", partner_id_required=True):
authorization = "Bearer " + self._create_token(
email="[email protected]"
)
with self._mock_request(authorization=authorization):
with self.assertRaises(UnauthorizedPartnerNotFound):
self.env["ir.http"]._auth_method_jwt_validator6()
def test_get_validator(self):
AuthJwtValidator = self.env["auth.jwt.validator"]
AuthJwtValidator.search([]).unlink()
with self.assertRaises(JwtValidatorNotFound), mute_logger(
"odoo.addons.auth_jwt.models.auth_jwt_validator"
):
AuthJwtValidator._get_validator_by_name(None)
with self.assertRaises(JwtValidatorNotFound), mute_logger(
"odoo.addons.auth_jwt.models.auth_jwt_validator"
):
AuthJwtValidator._get_validator_by_name("notavalidator")
validator1 = self._create_validator(name="validator1")
with self.assertRaises(JwtValidatorNotFound), mute_logger(
"odoo.addons.auth_jwt.models.auth_jwt_validator"
):
AuthJwtValidator._get_validator_by_name("notavalidator")
self.assertEqual(AuthJwtValidator._get_validator_by_name(None), validator1)
self.assertEqual(
AuthJwtValidator._get_validator_by_name("validator1"), validator1
)
# create a second validator
validator2 = self._create_validator(name="validator2")
with self.assertRaises(AmbiguousJwtValidator), mute_logger(
"odoo.addons.auth_jwt.models.auth_jwt_validator"
):
AuthJwtValidator._get_validator_by_name(None)
self.assertEqual(
AuthJwtValidator._get_validator_by_name("validator2"), validator2
)
def test_bad_tokens(self):
validator = self._create_validator("validator")
token = self._create_token(key="badsecret")
with self.assertRaises(UnauthorizedInvalidToken):
validator._decode(token)
token = self._create_token(audience="badaudience")
with self.assertRaises(UnauthorizedInvalidToken):
validator._decode(token)
token = self._create_token(issuer="badissuer")
with self.assertRaises(UnauthorizedInvalidToken):
validator._decode(token)
token = self._create_token(exp_delta=-100)
with self.assertRaises(UnauthorizedInvalidToken):
validator._decode(token)
def test_multiple_aud(self):
validator = self._create_validator("validator", audience="a1,a2")
token = self._create_token(audience="a1")
validator._decode(token)
token = self._create_token(audience="a2")
validator._decode(token)
token = self._create_token(audience="a3")
with self.assertRaises(UnauthorizedInvalidToken):
validator._decode(token)
def test_nbf(self):
validator = self._create_validator("validator")
token = self._create_token(nbf=time.time() - 60)
validator._decode(token)
token = self._create_token(nbf=time.time() + 60)
with self.assertRaises(UnauthorizedInvalidToken):
validator._decode(token)
def test_auth_method_registration_on_create(self):
IrHttp = self.env["ir.http"]
self.assertFalse(hasattr(IrHttp.__class__, "_auth_method_jwt_validator1"))
self.assertFalse(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator1")
)
self._create_validator("validator1")
self.assertTrue(hasattr(IrHttp.__class__, "_auth_method_jwt_validator1"))
self.assertTrue(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator1")
)
def test_auth_method_unregistration_on_unlink(self):
IrHttp = self.env["ir.http"]
validator = self._create_validator("validator1")
self.assertTrue(hasattr(IrHttp.__class__, "_auth_method_jwt_validator1"))
self.assertTrue(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator1")
)
validator.unlink()
self.assertFalse(hasattr(IrHttp.__class__, "_auth_method_jwt_validator1"))
self.assertFalse(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator1")
)
def test_auth_method_registration_on_rename(self):
IrHttp = self.env["ir.http"]
validator = self._create_validator("validator1")
self.assertTrue(hasattr(IrHttp.__class__, "_auth_method_jwt_validator1"))
self.assertTrue(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator1")
)
validator.name = "validator2"
self.assertFalse(hasattr(IrHttp.__class__, "_auth_method_jwt_validator1"))
self.assertFalse(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator1")
)
self.assertTrue(hasattr(IrHttp.__class__, "_auth_method_jwt_validator2"))
self.assertTrue(
hasattr(IrHttp.__class__, "_auth_method_public_or_jwt_validator2")
)
def test_name_check(self):
with self.assertRaises(ValidationError):
self._create_validator(name="not an identifier")
def test_public_or_jwt_no_token(self):
with self._mock_request(authorization=None) as request:
self.env["ir.http"]._auth_method_public_or_jwt()
assert request.uid == self.env.ref("base.public_user").id
assert not hasattr(request, "jwt_payload")
def test_public_or_jwt_valid_token(self):
with self._commit_validator("validator"):
authorization = "Bearer " + self._create_token()
with self._mock_request(authorization=authorization) as request:
self.env["ir.http"]._auth_method_public_or_jwt_validator()
assert request.jwt_payload["aud"] == "me"
| 42.330033 | 12,826 |
3,596 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
import re
from odoo import SUPERUSER_ID, api, models, registry as registry_get
from odoo.http import request
from ..exceptions import (
UnauthorizedMalformedAuthorizationHeader,
UnauthorizedMissingAuthorizationHeader,
UnauthorizedSessionMismatch,
)
_logger = logging.getLogger(__name__)
AUTHORIZATION_RE = re.compile(r"^Bearer ([^ ]+)$")
class IrHttpJwt(models.AbstractModel):
_inherit = "ir.http"
@classmethod
def _authenticate(cls, endpoint):
"""Protect the _authenticate method.
This is to ensure that the _authenticate method is called
in the correct conditions to invoke _auth_method_jwt below.
When migrating, review this method carefully by reading the original
_authenticate method and make sure the conditions have not changed.
"""
auth_method = endpoint.routing["auth"]
if (
auth_method in ("jwt", "public_or_jwt")
or auth_method.startswith("jwt_")
or auth_method.startswith("public_or_jwt_")
):
if request.session.uid:
_logger.warning(
'A route with auth="jwt" must not be used within a user session.'
)
raise UnauthorizedSessionMismatch()
# Odoo calls _authenticate more than once (in v14? why?), so
# on the second call we have a request uid and that is not an error
# because _authenticate will not call _auth_method_jwt a second time.
if request.uid and not hasattr(request, "jwt_payload"):
_logger.error(
"A route with auth='jwt' should not have a request.uid here."
)
raise UnauthorizedSessionMismatch()
return super()._authenticate(endpoint)
@classmethod
def _auth_method_jwt(cls, validator_name=None):
assert request.db
assert not request.uid
assert not request.session.uid
token = cls._get_bearer_token()
assert token
registry = registry_get(request.db)
with registry.cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, {})
validator = env["auth.jwt.validator"]._get_validator_by_name(validator_name)
assert len(validator) == 1
payload = validator._decode(token)
uid = validator._get_and_check_uid(payload)
assert uid
partner_id = validator._get_and_check_partner_id(payload)
request.uid = uid # this resets request.env
request.jwt_payload = payload
request.jwt_partner_id = partner_id
@classmethod
def _auth_method_public_or_jwt(cls, validator_name=None):
if "HTTP_AUTHORIZATION" not in request.httprequest.environ:
return cls._auth_method_public()
return cls._auth_method_jwt(validator_name)
@classmethod
def _get_bearer_token(cls):
# https://tools.ietf.org/html/rfc2617#section-3.2.2
authorization = request.httprequest.environ.get("HTTP_AUTHORIZATION")
if not authorization:
_logger.info("Missing Authorization header.")
raise UnauthorizedMissingAuthorizationHeader()
# https://tools.ietf.org/html/rfc6750#section-2.1
mo = AUTHORIZATION_RE.match(authorization)
if not mo:
_logger.info("Malformed Authorization header.")
raise UnauthorizedMalformedAuthorizationHeader()
return mo.group(1)
| 38.255319 | 3,596 |
7,697 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 ACSONE SA/NV
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
import logging
from functools import partial
import jwt # pylint: disable=missing-manifest-dependency
from jwt import PyJWKClient
from werkzeug.exceptions import InternalServerError
from odoo import _, api, fields, models, tools
from odoo.exceptions import ValidationError
from ..exceptions import (
AmbiguousJwtValidator,
JwtValidatorNotFound,
UnauthorizedInvalidToken,
UnauthorizedPartnerNotFound,
)
_logger = logging.getLogger(__name__)
class AuthJwtValidator(models.Model):
_name = "auth.jwt.validator"
_description = "JWT Validator Configuration"
name = fields.Char(required=True)
signature_type = fields.Selection(
[("secret", "Secret"), ("public_key", "Public key")], required=True
)
secret_key = fields.Char()
secret_algorithm = fields.Selection(
[
# https://pyjwt.readthedocs.io/en/stable/algorithms.html
("HS256", "HS256 - HMAC using SHA-256 hash algorithm"),
("HS384", "HS384 - HMAC using SHA-384 hash algorithm"),
("HS512", "HS512 - HMAC using SHA-512 hash algorithm"),
],
default="HS256",
)
public_key_jwk_uri = fields.Char()
public_key_algorithm = fields.Selection(
[
# https://pyjwt.readthedocs.io/en/stable/algorithms.html
("ES256", "ES256 - ECDSA using SHA-256"),
("ES256K", "ES256K - ECDSA with secp256k1 curve using SHA-256"),
("ES384", "ES384 - ECDSA using SHA-384"),
("ES512", "ES512 - ECDSA using SHA-512"),
("RS256", "RS256 - RSASSA-PKCS1-v1_5 using SHA-256"),
("RS384", "RS384 - RSASSA-PKCS1-v1_5 using SHA-384"),
("RS512", "RS512 - RSASSA-PKCS1-v1_5 using SHA-512"),
("PS256", "PS256 - RSASSA-PSS using SHA-256 and MGF1 padding with SHA-256"),
("PS384", "PS384 - RSASSA-PSS using SHA-384 and MGF1 padding with SHA-384"),
("PS512", "PS512 - RSASSA-PSS using SHA-512 and MGF1 padding with SHA-512"),
],
default="RS256",
)
audience = fields.Char(
required=True, help="Comma separated list of audiences, to validate aud."
)
issuer = fields.Char(required=True, help="To validate iss.")
user_id_strategy = fields.Selection(
[("static", "Static")], required=True, default="static"
)
static_user_id = fields.Many2one("res.users", default=1)
partner_id_strategy = fields.Selection([("email", "From email claim")])
partner_id_required = fields.Boolean()
_sql_constraints = [
("name_uniq", "unique(name)", "JWT validator names must be unique !"),
]
@api.constrains("name")
def _check_name(self):
for rec in self:
if not rec.name.isidentifier():
raise ValidationError(
_("Name %r is not a valid python identifier.") % (rec.name,)
)
@api.model
def _get_validator_by_name_domain(self, validator_name):
if validator_name:
return [("name", "=", validator_name)]
return []
@api.model
def _get_validator_by_name(self, validator_name):
domain = self._get_validator_by_name_domain(validator_name)
validator = self.search(domain)
if not validator:
_logger.error("JWT validator not found for name %r", validator_name)
raise JwtValidatorNotFound()
if len(validator) != 1:
_logger.error(
"More than one JWT validator found for name %r", validator_name
)
raise AmbiguousJwtValidator()
return validator
@tools.ormcache("self.public_key_jwk_uri", "kid")
def _get_key(self, kid):
jwks_client = PyJWKClient(self.public_key_jwk_uri, cache_keys=False)
return jwks_client.get_signing_key(kid).key
def _decode(self, token):
"""Validate and decode a JWT token, return the payload."""
if self.signature_type == "secret":
key = self.secret_key
algorithm = self.secret_algorithm
else:
try:
header = jwt.get_unverified_header(token)
except Exception as e:
_logger.info("Invalid token: %s", e)
raise UnauthorizedInvalidToken()
key = self._get_key(header.get("kid"))
algorithm = self.public_key_algorithm
try:
payload = jwt.decode(
token,
key=key,
algorithms=[algorithm],
options=dict(
require=["exp", "aud", "iss"],
verify_exp=True,
verify_aud=True,
verify_iss=True,
),
audience=self.audience.split(","),
issuer=self.issuer,
)
except Exception as e:
_logger.info("Invalid token: %s", e)
raise UnauthorizedInvalidToken()
return payload
def _get_uid(self, payload):
# override for additional strategies
if self.user_id_strategy == "static":
return self.static_user_id.id
def _get_and_check_uid(self, payload):
uid = self._get_uid(payload)
if not uid:
_logger.error("_get_uid did not return a user id")
raise InternalServerError()
return uid
def _get_partner_id(self, payload):
# override for additional strategies
if self.partner_id_strategy == "email":
email = payload.get("email")
if not email:
_logger.debug("JWT payload does not have an email claim")
return
partner = self.env["res.partner"].search([("email", "=", email)])
if len(partner) != 1:
_logger.debug("%d partners found for email %s", len(partner), email)
return
return partner.id
def _get_and_check_partner_id(self, payload):
partner_id = self._get_partner_id(payload)
if not partner_id and self.partner_id_required:
raise UnauthorizedPartnerNotFound()
return partner_id
def _register_hook(self):
res = super()._register_hook()
self.search([])._register_auth_method()
return res
def _register_auth_method(self):
IrHttp = self.env["ir.http"]
for rec in self:
setattr(
IrHttp.__class__,
f"_auth_method_jwt_{rec.name}",
partial(IrHttp.__class__._auth_method_jwt, validator_name=rec.name),
)
setattr(
IrHttp.__class__,
f"_auth_method_public_or_jwt_{rec.name}",
partial(
IrHttp.__class__._auth_method_public_or_jwt, validator_name=rec.name
),
)
def _unregister_auth_method(self):
IrHttp = self.env["ir.http"]
for rec in self:
try:
delattr(IrHttp.__class__, f"_auth_method_jwt_{rec.name}")
delattr(IrHttp.__class__, f"_auth_method_public_or_jwt_{rec.name}")
except AttributeError:
pass
@api.model_create_multi
def create(self, vals):
rec = super().create(vals)
rec._register_auth_method()
return rec
def write(self, vals):
if "name" in vals:
self._unregister_auth_method()
res = super().write(vals)
self._register_auth_method()
return res
def unlink(self):
self._unregister_auth_method()
return super().unlink()
| 35.8 | 7,697 |
1,165 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 LasLabs Inc.
# Copyright 2021 Open Source Integrators
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
from odoo import _
from odoo.exceptions import ValidationError
def pre_init_hook_login_check(cr):
"""This hook will look to see if any conflicting logins exist before
the module is installed
:param openerp.sql_db.Cursor cr:
Database cursor.
"""
with cr.savepoint():
users = []
cr.execute("SELECT login FROM res_users")
for user in cr.fetchall():
login = user[0].lower()
if login not in users:
users.append(login)
else:
raise ValidationError(
_("Conflicting user logins exist for `%s`", login)
)
def post_init_hook_login_convert(cr, registry):
"""After the module is installed, set all logins to lowercase
:param openerp.sql_db.Cursor cr:
Database cursor.
:param openerp.modules.registry.RegistryManager registry:
Database registry, using v7 api.
"""
with cr.savepoint():
cr.execute("UPDATE res_users SET login=lower(login)")
| 32.361111 | 1,165 |
684 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2017 LasLabs Inc.
# Copyright 2021 Open Source Integrators
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
{
"name": "Case Insensitive Logins",
"summary": "Makes the user login field case insensitive",
"version": "15.0.1.0.0",
"category": "Authentication",
"website": "https://github.com/OCA/server-auth",
"author": "LasLabs, Odoo Community Association (OCA)",
"maintainer": "Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["mail"],
"pre_init_hook": "pre_init_hook_login_check",
"post_init_hook": "post_init_hook_login_convert",
}
| 38 | 684 |
1,990 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2017 LasLabs Inc.
# Copyright 2021 Open Source Integrators
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo.tests.common import TransactionCase
class TestResUsers(TransactionCase):
def setUp(self):
super(TestResUsers, self).setUp()
self.login = "[email protected]"
self.partner_vals = {
"name": "Partner",
"is_company": False,
"email": self.login,
}
self.vals = {"name": "User", "login": self.login, "password": "password"}
self.model_obj = self.env["res.users"]
def _new_record(self):
"""Gnerate a new record to test with."""
partner_id = self.env["res.partner"].create(self.partner_vals)
self.vals["partner_id"] = partner_id.id
return self.model_obj.create(self.vals)
def test_login_is_lowercased_on_create(self):
"""Verify the login is set to lowercase on create."""
rec_id = self._new_record()
self.assertEqual(
self.login.lower(),
rec_id.login,
"Login was not lowercased when saved to db.",
)
def test_login_is_lowercased_on_write(self):
"""Verify the login is set to lowercase on write."""
rec_id = self._new_record()
rec_id.write({"login": self.login})
self.assertEqual(
self.login.lower(),
rec_id.login,
"Login was not lowercased when saved to db.",
)
def test_login_login_is_lowercased(self):
"""verify the login is set to lowercase on login."""
rec_id = self.model_obj.search([("login", "=", "admin")])
res_id = self.model_obj._login(
self.env.registry.db_name,
"AdMiN",
"admin",
{"interactive": True},
)
self.assertEqual(
rec_id.id,
res_id,
"Login with with uppercase chars was not \
successful",
)
| 33.728814 | 1,990 |
1,106 |
py
|
PYTHON
|
15.0
|
# Copyright 2015-2017 LasLabs Inc.
# Copyright 2021 Open Source Integrators
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl.html).
from odoo import api, fields, models
class ResUsers(models.Model):
_inherit = "res.users"
login = fields.Char(help="Used to log into the system. Case insensitive.")
@classmethod
def _login(cls, db, login, password, user_agent_env):
"""Overload _login to lowercase the `login` before passing to the
super."""
login = login.lower()
return super(ResUsers, cls)._login(
db, login, password, user_agent_env=user_agent_env
)
@api.model_create_multi
def create(self, vals_list):
"""Overload create multiple to lowercase login."""
for val in vals_list:
val["login"] = val.get("login", "").lower()
return super(ResUsers, self).create(vals_list)
def write(self, vals):
"""Overload write to lowercase login."""
if vals.get("login"):
vals["login"] = vals["login"].lower()
return super(ResUsers, self).write(vals)
| 32.529412 | 1,106 |
1,322 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Vault - Share",
"summary": "Implementation of a mechanism to share secrets",
"license": "AGPL-3",
"version": "15.0.1.1.1",
"website": "https://github.com/OCA/server-auth",
"application": False,
"author": "initOS GmbH, Odoo Community Association (OCA)",
"category": "Vault",
"depends": ["vault"],
"data": [
"data/ir_cron.xml",
"security/ir.model.access.csv",
"security/ir_rule.xml",
"views/menuitems.xml",
"views/res_config_settings_views.xml",
"views/templates.xml",
"views/vault_share_views.xml",
],
"assets": {
"web.assets_backend": [
"vault_share/static/src/common/**/*.js",
"vault_share/static/src/backend/**/*.js",
"vault_share/static/src/backend/**/*.scss",
"vault_share/static/src/legacy/vault_fields.js",
"vault_share/static/src/legacy/vault_share_widget.js",
],
"vault_share.assets_frontend": [
"vault/static/src/common/*.js",
"vault_share/static/src/frontend/*.js",
],
"web.assets_qweb": [
"vault_share/static/src/backend/**/*.xml",
],
},
}
| 33.871795 | 1,321 |
2,237 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from datetime import datetime
from uuid import uuid4
from odoo.tests import TransactionCase
from odoo.tools import mute_logger
from odoo.addons.website.tools import MockRequest
from ..controllers import main
_logger = logging.getLogger(__name__)
class TestShare(TransactionCase):
def setUp(self):
super().setUp()
self.user = self.env.user
self.vals = {
"name": f"Share {self.user.name}",
"secret": "secret",
"salt": "sa17",
"iv": "1v",
"pin": "12345",
}
self.share = self.env["vault.share"].create(self.vals)
@mute_logger("odoo.sql_db")
def test_share(self):
self.assertEqual(self.share, self.share.get(self.share.token))
self.assertIn(self.share.token, self.share.share_link)
# Nothing should happen
self.share.clean()
self.assertEqual(self.share, self.share.get(self.share.token))
# Deletion because of accesses
share = self.share.create(self.vals)
share.accesses = 0
self.assertEqual(None, share.get(share.token))
# Deletion because of expiration
share = self.share.create(self.vals)
share.expiration = datetime(1970, 1, 1)
self.assertEqual(None, share.get(share.token))
# Search for invalid token
self.assertEqual(share.browse(), share.get(uuid4()))
@mute_logger("odoo.sql_db")
def test_vault_share(self):
def return_context(template, context):
self.assertEqual(template, "vault_share.share")
return context
with MockRequest(self.env) as request_mock:
request_mock.render = return_context
controller = main.Controller()
response = controller.vault_share("")
self.assertIn("error", response)
response = controller.vault_share(self.share.token)
self.assertEqual(response["salt"], self.share.salt)
self.share.accesses = 0
response = controller.vault_share(self.share.token)
self.assertIn("error", response)
| 30.630137 | 2,236 |
511 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, fields, models
_logger = logging.getLogger(__name__)
class VaultShareLog(models.Model):
_name = "vault.share.log"
_description = _("Vault share log")
_order = "create_date DESC"
share_id = fields.Many2one(
"vault.share",
ondelete="cascade",
readonly=True,
required=True,
)
name = fields.Char(readonly=True)
| 23.181818 | 510 |
254 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class RecCompany(models.Model):
_inherit = "res.company"
vault_share_delay = fields.Integer(default=0)
| 25.3 | 253 |
2,761 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from datetime import datetime, timedelta
from uuid import uuid4
from odoo import _, api, fields, models
_logger = logging.getLogger(__name__)
class VaultShare(models.Model):
_name = "vault.share"
_description = _("Vault share outgoing secrets")
user_id = fields.Many2one("res.users", default=lambda self: self.env.uid)
name = fields.Char(required=True)
share_link = fields.Char(
"Share URL",
compute="_compute_url",
store=False,
help="Using this link and pin people can access the secret.",
)
token = fields.Char(readonly=True, required=True, default=lambda self: uuid4())
secret = fields.Char()
secret_file = fields.Char()
filename = fields.Char()
salt = fields.Char(required=True)
iv = fields.Char(required=True)
pin = fields.Char(required=True, help="The pin needed to decrypt the share.")
accesses = fields.Integer(
"Access counter",
default=5,
help="Specifies how often a share can be accessed before deletion.",
)
expiration = fields.Datetime(
default=lambda self: datetime.now() + timedelta(days=7),
help="Specifies how long a share can be accessed until deletion.",
)
log_ids = fields.One2many("vault.share.log", "share_id", "Log", readonly=True)
_sql_constraints = [
(
"value_check",
"CHECK(secret IS NOT NULL OR secret_file IS NOT NULL)",
_("No value found"),
),
]
@api.depends("token")
def _compute_url(self):
base_url = self.env["ir.config_parameter"].sudo().get_param("web.base.url")
for rec in self:
rec.share_link = f"{base_url}/vault/share/{rec.token}"
@api.model
def get(self, token, ip=None):
rec = self.search([("token", "=", token)], limit=1)
if not rec:
return rec
if datetime.now() < rec.expiration and rec.accesses > 0:
rec.accesses -= 1
log = _("The share was accessed by %(name)s via %(ip)s")
rec.log_ids = [
(0, 0, {"name": log % {"name": self.env.user.name, "ip": ip or "n/a"}})
]
return rec
return None
@api.model
def create(self, vals):
rec = super().create(vals)
log = _("The share was created by %(name)s")
rec.log_ids = [(0, 0, {"name": log % {"name": self.env.user.name}})]
return rec
@api.model
def clean(self):
now = datetime.now()
offset = timedelta(days=self.env.company.vault_share_delay)
self.search([("expiration", "<=", now + offset)]).unlink()
| 32.857143 | 2,760 |
695 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import api, fields, models
_logger = logging.getLogger(__name__)
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
vault_share_delay = fields.Integer(
string="Delayed Deletion",
related="company_id.vault_share_delay",
readonly=False,
help="Delays the deletion of a share. After the expiration date it continues "
"to stay inaccessible",
)
@api.onchange("vault_share_delay")
def _on_change_mins(self):
self.vault_share_delay = max(0, self.vault_share_delay)
| 28.916667 | 694 |
1,141 |
py
|
PYTHON
|
15.0
|
# © 2021 Florian Kantelberg - initOS GmbH
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from odoo import _, http
from odoo.http import request
_logger = logging.getLogger(__name__)
class Controller(http.Controller):
@http.route("/vault/share/<string:token>", type="http", auth="public")
def vault_share(self, token):
ctx = {"disable_footer": True, "token": token}
share = request.env["vault.share"].sudo()
secret = share.get(token, ip=request.httprequest.remote_addr)
if secret is None:
ctx["error"] = _("The secret expired")
return request.render("vault_share.share", ctx)
if len(secret) != 1:
ctx["error"] = _("Invalid token")
return request.render("vault_share.share", ctx)
ctx.update(
{
"encrypted": secret.secret,
"salt": secret.salt,
"iv": secret.iv,
"encrypted_file": secret.secret_file,
"filename": secret.filename,
}
)
return request.render("vault_share.share", ctx)
| 32.571429 | 1,140 |
631 |
py
|
PYTHON
|
15.0
|
# (c) 2015 ACSONE SA/NV, Dhinesh D
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Inactive Sessions Timeout",
"summary": """
This module disable all inactive sessions since a given delay""",
"author": "ACSONE SA/NV, "
"Dhinesh D, "
"Jesse Morgan, "
"LasLabs, "
"Odoo Community Association (OCA)",
"maintainer": "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-auth",
"category": "Tools",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"data": ["data/ir_config_parameter_data.xml"],
"installable": True,
}
| 31.55 | 631 |
4,779 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-2017 LasLabs Inc.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import time
from contextlib import contextmanager
import mock
from odoo.http import SessionExpiredException
from odoo.tests.common import TransactionCase
from odoo.tools.misc import mute_logger
class EndTestException(Exception):
"""It stops tests from continuing"""
class TestResUsers(TransactionCase):
def setUp(self):
super(TestResUsers, self).setUp()
self.ResUsers = self.env["res.users"]
@contextmanager
def _mock_assets(self, assets=None):
"""It provides mocked imports from res_users.py
:param assets: (list) Name of imports to mock. Mocks `http` if None
:return: (dict) Dictionary of mocks, keyed by module name
"""
if assets is None:
assets = ["http"]
patches = {name: mock.DEFAULT for name in assets}
with mock.patch.multiple(
"odoo.addons.auth_session_timeout.models.res_users", **patches
) as mocks:
yield mocks
def _auth_timeout_check(self, http_mock):
"""It wraps ``_auth_timeout_check`` for easier calling"""
self.db = mock.MagicMock()
self.uid = mock.MagicMock()
self.passwd = mock.MagicMock()
self.path = "/this/is/a/test/path"
get_filename = http_mock.root.session_store.get_session_filename
get_filename.return_value = self.path
return self.ResUsers._auth_timeout_check()
def test_session_validity_no_request(self):
"""It should return immediately if no request"""
with self._mock_assets() as assets:
assets["http"].request = False
res = self._auth_timeout_check(assets["http"])
self.assertFalse(res)
def test_session_validity_gets_session_file(self):
"""It should call get the session file for the session id"""
with self._mock_assets() as assets:
get_params = assets["http"].request.env[""].get_session_parameters
get_params.return_value = 0, []
store = assets["http"].root.session_store
store.get_session_filename.side_effect = EndTestException
with self.assertRaises(EndTestException):
self._auth_timeout_check(assets["http"])
store.get_session_filename.assert_called_once_with(
assets["http"].request.session.sid,
)
def test_session_validity_logout(self):
"""It should log out of session if past deadline"""
with self._mock_assets(["http", "getmtime", "utime"]) as assets:
get_params = assets["http"].request.env[""].get_session_parameters
get_params.return_value = -9999, []
assets["getmtime"].return_value = 0
with self.assertRaises(SessionExpiredException):
self._auth_timeout_check(assets["http"])
assets["http"].request.session.logout.assert_called_once_with(
keep_db=True,
)
def test_session_validity_updates_utime(self):
"""It should update utime of session file if not expired"""
with self._mock_assets(["http", "getmtime", "utime"]) as assets:
get_params = assets["http"].request.env[""].get_session_parameters
get_params.return_value = 9999, []
assets["getmtime"].return_value = time.time()
self._auth_timeout_check(assets["http"])
assets["utime"].assert_called_once_with(
assets["http"].root.session_store.get_session_filename(),
None,
)
@mute_logger("odoo.addons.auth_session_timeout.models.res_users")
def test_session_validity_os_error_guard(self):
"""It should properly guard from OSError & return"""
with self._mock_assets(["http", "utime", "getmtime"]) as assets:
get_params = assets["http"].request.env[""].get_session_parameters
get_params.return_value = 0, []
assets["getmtime"].side_effect = OSError
with self.assertRaises(SessionExpiredException):
self._auth_timeout_check(assets["http"])
def test_on_timeout_session_loggedout(self):
with self._mock_assets(["http", "getmtime"]) as assets:
assets["getmtime"].return_value = 0
assets["http"].request.session.uid = self.env.uid
assets["http"].request.session.dbname = self.env.cr.dbname
assets["http"].request.session.sid = 123
assets["http"].request.session.logout = mock.Mock()
with self.assertRaises(SessionExpiredException):
self.ResUsers._auth_timeout_check()
self.assertTrue(assets["http"].request.session.logout.called)
| 43.445455 | 4,779 |
2,796 |
py
|
PYTHON
|
15.0
|
# (c) 2015 ACSONE SA/NV, Dhinesh D
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
class TestIrConfigParameter(common.TransactionCase):
def setUp(self):
super(TestIrConfigParameter, self).setUp()
self.db = self.env.cr.dbname
self.param_obj = self.env["ir.config_parameter"]
self.data_obj = self.env["ir.model.data"]
self.delay = self.env.ref(
"auth_session_timeout.inactive_session_time_out_delay"
)
def test_check_session_param_delay(self):
delay = self.param_obj._auth_timeout_get_parameter_delay()
self.assertEqual(delay, int(self.delay.value))
self.assertIsInstance(delay, int)
def test_check_session_param_urls(self):
urls = self.param_obj._auth_timeout_get_parameter_ignored_urls()
self.assertIsInstance(urls, list)
class TestIrConfigParameterCaching(common.TransactionCase):
def setUp(self):
super(TestIrConfigParameterCaching, self).setUp()
self.db = self.env.cr.dbname
self.param_obj = self.env["ir.config_parameter"]
self.get_param_called = False
test = self
def get_param(*args, **kwargs):
test.get_param_called = True
return orig_get_param(*args[1:], **kwargs)
orig_get_param = self.param_obj.get_param
self.param_obj._patch_method("get_param", get_param)
def tearDown(self):
super(TestIrConfigParameterCaching, self).tearDown()
self.param_obj._revert_method("get_param")
def test_auth_timeout_get_parameter_delay_cache(self):
"""It should cache the parameter call."""
self.get_param_called = False
self.param_obj._auth_timeout_get_parameter_delay()
self.assertTrue(self.get_param_called)
def test_auth_timeout_get_parameter_ignored_urls_cache(self):
"""It should cache the parameter call."""
self.get_param_called = False
self.param_obj._auth_timeout_get_parameter_ignored_urls()
self.assertTrue(self.get_param_called)
def test_check_param_writes_clear_delay_cache(self):
self.param_obj._auth_timeout_get_parameter_delay()
self.get_param_called = False
self.param_obj.set_param("inactive_session_time_out_delay", 7201)
self.param_obj._auth_timeout_get_parameter_delay()
self.assertTrue(self.get_param_called)
def test_check_param_writes_clear_ignore_url_cache(self):
self.param_obj._auth_timeout_get_parameter_ignored_urls()
self.get_param_called = False
self.param_obj.set_param("inactive_session_time_out_ignored_url", "example.com")
self.param_obj._auth_timeout_get_parameter_ignored_urls()
self.assertTrue(self.get_param_called)
| 39.380282 | 2,796 |
509 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
from odoo.http import request
class IrHttp(models.AbstractModel):
_inherit = "ir.http"
@classmethod
def _authenticate(cls, endpoint):
res = super(IrHttp, cls)._authenticate(endpoint=endpoint)
auth_method = endpoint.routing["auth"]
if auth_method == "user" and request and request.env and request.env.user:
request.env.user._auth_timeout_check()
return res
| 31.8125 | 509 |
1,313 |
py
|
PYTHON
|
15.0
|
# (c) 2015 ACSONE SA/NV, Dhinesh D
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models, tools
DELAY_KEY = "inactive_session_time_out_delay"
IGNORED_PATH_KEY = "inactive_session_time_out_ignored_url"
class IrConfigParameter(models.Model):
_inherit = "ir.config_parameter"
@api.model
@tools.ormcache("self.env.cr.dbname")
def _auth_timeout_get_parameter_delay(self):
return int(
self.env["ir.config_parameter"]
.sudo()
.get_param(
DELAY_KEY,
7200,
)
)
@api.model
@tools.ormcache("self.env.cr.dbname")
def _auth_timeout_get_parameter_ignored_urls(self):
urls = (
self.env["ir.config_parameter"]
.sudo()
.get_param(
IGNORED_PATH_KEY,
"",
)
)
return urls.split(",")
def write(self, vals):
res = super(IrConfigParameter, self).write(vals)
self._auth_timeout_get_parameter_delay.clear_cache(
self.filtered(lambda r: r.key == DELAY_KEY),
)
self._auth_timeout_get_parameter_ignored_urls.clear_cache(
self.filtered(lambda r: r.key == IGNORED_PATH_KEY),
)
return res
| 28.543478 | 1,313 |
3,277 |
py
|
PYTHON
|
15.0
|
# (c) 2015 ACSONE SA/NV, Dhinesh D
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
from os import utime
from os.path import getmtime
from time import time
from odoo import api, http, models
from odoo.http import SessionExpiredException
_logger = logging.getLogger(__name__)
class ResUsers(models.Model):
_inherit = "res.users"
@api.model
def _auth_timeout_get_ignored_urls(self):
"""Pluggable method for calculating ignored urls
Defaults to stored config param
"""
params = self.env["ir.config_parameter"]
return params._auth_timeout_get_parameter_ignored_urls()
@api.model
def _auth_timeout_deadline_calculate(self):
"""Pluggable method for calculating timeout deadline
Defaults to current time minus delay using delay stored as config
param.
"""
params = self.env["ir.config_parameter"]
delay = params._auth_timeout_get_parameter_delay()
if delay <= 0:
return False
return time() - delay
@api.model
def _auth_timeout_session_terminate(self, session):
"""Pluggable method for terminating a timed-out session
This is a late stage where a session timeout can be aborted.
Useful if you want to do some heavy checking, as it won't be
called unless the session inactivity deadline has been reached.
Return:
True: session terminated
False: session timeout cancelled
"""
if session.db and session.uid:
session.logout(keep_db=True)
return True
@api.model
def _auth_timeout_check(self):
"""Perform session timeout validation and expire if needed."""
if not http.request:
return
session = http.request.session
# Calculate deadline
deadline = self._auth_timeout_deadline_calculate()
# Check if past deadline
expired = False
if deadline is not False:
path = http.root.session_store.get_session_filename(session.sid)
try:
expired = getmtime(path) < deadline
except OSError:
_logger.exception(
"Exception reading session file modified time.",
)
# Force expire the session. Will be resolved with new session.
expired = True
# Try to terminate the session
terminated = False
if expired:
terminated = self._auth_timeout_session_terminate(session)
# If session terminated, all done
if terminated:
raise SessionExpiredException("Session expired")
# Else, conditionally update session modified and access times
ignored_urls = self._auth_timeout_get_ignored_urls()
if http.request.httprequest.path not in ignored_urls:
if "path" not in locals():
path = http.root.session_store.get_session_filename(
session.sid,
)
try:
utime(path, None)
except OSError:
_logger.exception(
"Exception updating session file access/modified times.",
)
| 31.815534 | 3,277 |
1,522 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2020 GlodoUK <https://www.glodo.uk/>
# Copyright (C) 2010-2016, 2022 XCG Consulting <http://odoo.consulting>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "SAML2 Authentication",
"version": "15.0.1.2.1",
"category": "Tools",
"author": "XCG Consulting, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/server-auth",
"license": "AGPL-3",
"depends": ["base_setup"],
"external_dependencies": {
# Place an upper bound on cryptography version to be compatible with
# pyopenssl 19 mentioned in Odoo 15's requirements.txt. If we don't do
# this, installing this module will try to upgrade cryptography to the latest
# version because the minimum required version in pysaml2 (>=3.1) is greater than
# version 2.6 (from Odoo's requirement.txt). Since cryptography/pyopenssl don't
# declare minimum supported versions, this lead to inconsistencies.
# https://github.com/OCA/server-auth/issues/424
"python": ["pysaml2", "cryptography<37"],
"bin": ["xmlsec1"],
# special definition used by OCA to install packages
"deb": ["xmlsec1"],
},
"demo": [],
"data": [
"data/ir_config_parameter.xml",
"security/ir.model.access.csv",
"views/auth_saml.xml",
"views/res_config_settings.xml",
"views/res_users.xml",
],
"installable": True,
"auto_install": False,
"development_status": "Beta",
}
| 41.135135 | 1,522 |
10,152 |
py
|
PYTHON
|
15.0
|
import base64
import os
from odoo.exceptions import AccessDenied, UserError, ValidationError
from odoo.tests import HttpCase, tagged
from .fake_idp import FakeIDP
@tagged("saml", "post_install", "-at_install")
class TestPySaml(HttpCase):
def setUp(self):
super().setUp()
sp_pem_public = None
sp_pem_private = None
with open(
os.path.join(os.path.dirname(__file__), "data", "sp.pem"),
"r",
encoding="UTF-8",
) as file:
sp_pem_public = file.read()
with open(
os.path.join(os.path.dirname(__file__), "data", "sp.key"),
"r",
encoding="UTF-8",
) as file:
sp_pem_private = file.read()
self.saml_provider = self.env["auth.saml.provider"].create(
{
"name": "SAML Provider Demo",
"idp_metadata": FakeIDP().get_metadata(),
"sp_pem_public": base64.b64encode(sp_pem_public.encode()),
"sp_pem_private": base64.b64encode(sp_pem_private.encode()),
"body": "Login with Authentic",
"active": True,
"sig_alg": "SIG_RSA_SHA1",
"matching_attribute": "mail",
}
)
self.url_saml_request = (
"/auth_saml/get_auth_request?pid=%d" % self.saml_provider.id
)
self.idp = FakeIDP([self.saml_provider._metadata_string()])
# Create a user with only password, and another with both password and saml id
self.user, self.user2 = (
self.env["res.users"]
.with_context(no_reset_password=True, tracking_disable=True)
.create(
[
{
"name": "User",
"email": "[email protected]",
"login": "[email protected]",
"password": "Lu,ums-7vRU>0i]=YDLa",
},
{
"name": "User with SAML",
"email": "[email protected]",
"login": "[email protected]",
"password": "NesTNSte9340D720te>/-A",
"saml_ids": [
(
0,
0,
{
"saml_provider_id": self.saml_provider.id,
"saml_uid": "[email protected]",
},
)
],
},
]
)
)
def test_ensure_provider_appears_on_login(self):
# SAML provider should be listed in the login page
response = self.url_open("/web/login")
self.assertIn("Login with Authentic", response.text)
self.assertIn(self.url_saml_request, response.text)
def test_ensure_metadata_present(self):
response = self.url_open(
"/auth_saml/metadata?p=%d&d=%s"
% (self.saml_provider.id, self.env.cr.dbname)
)
self.assertTrue(response.ok)
self.assertTrue("xml" in response.headers.get("Content-Type"))
def test_ensure_get_auth_request_redirects(self):
response = self.url_open(
"/auth_saml/get_auth_request?pid=%d" % (self.saml_provider.id),
allow_redirects=False,
)
self.assertTrue(response.ok)
self.assertEqual(response.status_code, 303)
self.assertIn(
"http://localhost:8000/sso/redirect?SAMLRequest=",
response.headers.get("Location"),
)
def test_login_no_saml(self):
"""
Login with a user account, but without any SAML provider setup
against the user
"""
# Standard login using password
self.authenticate(user="[email protected]", password="Lu,ums-7vRU>0i]=YDLa")
self.assertEqual(self.session.uid, self.user.id)
self.logout()
# Try to log in with a non-existing SAML token
with self.assertRaises(AccessDenied):
self.authenticate(user="[email protected]", password="test_saml_token")
redirect_url = self.saml_provider._get_auth_request()
self.assertIn("http://localhost:8000/sso/redirect?SAMLRequest=", redirect_url)
response = self.idp.fake_login(redirect_url)
self.assertEqual(200, response.status_code)
unpacked_response = response._unpack()
with self.assertRaises(AccessDenied):
self.env["res.users"].sudo().auth_saml(
self.saml_provider.id, unpacked_response.get("SAMLResponse"), None
)
def add_provider_to_user(self):
"""Add a provider to self.user"""
self.user.write(
{
"saml_ids": [
(
0,
0,
{
"saml_provider_id": self.saml_provider.id,
"saml_uid": "[email protected]",
},
)
]
}
)
def test_login_with_saml(self):
self.add_provider_to_user()
redirect_url = self.saml_provider._get_auth_request()
self.assertIn("http://localhost:8000/sso/redirect?SAMLRequest=", redirect_url)
response = self.idp.fake_login(redirect_url)
self.assertEqual(200, response.status_code)
unpacked_response = response._unpack()
(_database, login, token) = (
self.env["res.users"]
.sudo()
.auth_saml(
self.saml_provider.id, unpacked_response.get("SAMLResponse"), None
)
)
self.assertEqual(login, self.user.login)
# We should not be able to log in with the wrong token
with self.assertRaises(AccessDenied):
self.authenticate(
user="[email protected]", password="{}-WRONG".format(token)
)
# User should now be able to log in with the token
self.authenticate(user="[email protected]", password=token)
def test_disallow_user_password_when_changing_setting(self):
"""Test that disabling users from having both a password and SAML ids remove
users password."""
# change the option
self.browse_ref(
"auth_saml.allow_saml_uid_and_internal_password"
).value = "False"
# The password should be blank and the user should not be able to connect
with self.assertRaises(AccessDenied):
self.authenticate(
user="[email protected]", password="NesTNSte9340D720te>/-A"
)
def test_disallow_user_password_new_user(self):
"""Test that a new user can not be set up with both password and SAML ids when
the disallow option is set."""
# change the option
self.browse_ref(
"auth_saml.allow_saml_uid_and_internal_password"
).value = "False"
with self.assertRaises(UserError):
self.env["res.users"].with_context(no_reset_password=True).create(
{
"name": "New user with SAML",
"email": "[email protected]",
"login": "[email protected]",
"password": "NesTNSte9340D720te>/-A",
"saml_ids": [
(
0,
0,
{
"saml_provider_id": self.saml_provider.id,
"saml_uid": "user2",
},
)
],
}
)
def test_disallow_user_password_no_password_set(self):
"""Test that a new user with SAML ids can not have its password set up when the
disallow option is set."""
# change the option
self.browse_ref(
"auth_saml.allow_saml_uid_and_internal_password"
).value = "False"
# Create a new user with only SAML ids
user = (
self.env["res.users"]
.with_context(no_reset_password=True, tracking_disable=True)
.create(
{
"name": "New user with SAML",
"email": "[email protected]",
"login": "[email protected]",
"saml_ids": [
(
0,
0,
{
"saml_provider_id": self.saml_provider.id,
"saml_uid": "unused",
},
)
],
}
)
)
# Assert that the user password can not be set
with self.assertRaises(ValidationError):
user.password = "new password"
def test_disallow_user_password(self):
"""Test that existing user password is deleted when adding an SAML provider when
the disallow option is set."""
# change the option
self.browse_ref(
"auth_saml.allow_saml_uid_and_internal_password"
).value = "False"
# Test that existing user password is deleted when adding an SAML provider
self.authenticate(user="[email protected]", password="Lu,ums-7vRU>0i]=YDLa")
self.add_provider_to_user()
with self.assertRaises(AccessDenied):
self.authenticate(user="[email protected]", password="Lu,ums-7vRU>0i]=YDLa")
def test_disallow_user_admin_can_have_password(self):
"""Test that admin can have its password set even if the disallow option is set."""
# change the option
self.browse_ref(
"auth_saml.allow_saml_uid_and_internal_password"
).value = "False"
# Test base.user_admin exception
self.env.ref("base.user_admin").password = "nNRST4j*->sEatNGg._!"
| 36.916364 | 10,152 |
4,904 |
py
|
PYTHON
|
15.0
|
import os
from urllib.parse import parse_qs, urlparse
from saml2 import BINDING_HTTP_POST, BINDING_HTTP_REDIRECT, pack
from saml2.authn_context import INTERNETPROTOCOLPASSWORD
from saml2.config import Config as Saml2Config
from saml2.metadata import create_metadata_string
from saml2.saml import NAME_FORMAT_URI, NAMEID_FORMAT_PERSISTENT
from saml2.server import Server
TYP = {"GET": [BINDING_HTTP_REDIRECT], "POST": [BINDING_HTTP_POST]}
AUTHN = {
"class_ref": INTERNETPROTOCOLPASSWORD,
"authn_auth": "http://www.example.com/login",
}
BASE = "http://localhost:8000"
CONFIG = {
"entityid": "urn:mace:example.com:saml:example:idp",
"name": "Rolands IdP",
"service": {
"aa": {
"endpoints": {
"attribute_service": [
("%s/aap" % BASE, BINDING_HTTP_POST),
]
},
},
"aq": {
"endpoints": {
"authn_query_service": [("%s/aqs" % BASE, BINDING_HTTP_POST)]
},
},
"idp": {
"endpoints": {
"single_sign_on_service": [
("%s/sso/redirect" % BASE, BINDING_HTTP_REDIRECT),
("%s/sso/post" % BASE, BINDING_HTTP_POST),
],
},
"policy": {
"default": {
"lifetime": {"minutes": 15},
"attribute_restrictions": None,
"name_form": NAME_FORMAT_URI,
},
"urn:mace:example.com:saml:example:sp": {
"lifetime": {"minutes": 5},
"nameid_format": NAMEID_FORMAT_PERSISTENT,
},
},
},
},
"debug": 1,
"key_file": os.path.join(os.path.dirname(__file__), "data", "idp.pem"),
"cert_file": os.path.join(os.path.dirname(__file__), "data", "idp.pem"),
"organization": {
"name": "Example",
"display_name": [("Example", "uk")],
"url": "http://www.example.com/",
},
"contact_person": [
{
"given_name": "Admin",
"sur_name": "Admin",
"email_address": ["[email protected]"],
"contact_type": "technical",
},
],
}
class DummyResponse:
def __init__(self, status, data, headers=None):
self.status_code = status
self.text = data
self.headers = headers or []
self.content = data
def _unpack(self, ver="SAMLResponse"):
"""
Unpack the response form
"""
_str = self.text
sr_str = 'name="%s" value="' % ver
rs_str = 'name="RelayState" value="'
i = _str.find(sr_str)
i += len(sr_str)
j = _str.find('"', i)
sr = _str[i:j]
start = _str.find(rs_str, j)
start += len(rs_str)
end = _str.find('"', start)
rs = _str[start:end]
return {ver: sr, "RelayState": rs}
class FakeIDP(Server):
def __init__(self, metadatas=None):
settings = CONFIG
if metadatas:
settings.update({"metadata": {"inline": metadatas}})
config = Saml2Config()
config.load(settings)
config.allow_unknown_attributes = True
Server.__init__(self, config=config)
def get_metadata(self):
return create_metadata_string(
None,
config=self.config,
sign=True,
valid=True,
cert=CONFIG.get("cert_file"),
keyfile=CONFIG.get("key_file"),
)
def fake_login(self, url):
# Assumes GET query and HTTP_REDIRECT only.
# This is all that auth_pysaml currently supports.
parsed_url = urlparse(url)
qs_dict = parse_qs(parsed_url.query)
samlreq = qs_dict["SAMLRequest"][0]
rstate = qs_dict["RelayState"][0]
# process the logon request, and automatically "login"
return self.authn_request_endpoint(samlreq, BINDING_HTTP_REDIRECT, rstate)
def authn_request_endpoint(self, req, binding, relay_state):
req = self.parse_authn_request(req, binding)
if req.message.protocol_binding == BINDING_HTTP_REDIRECT:
_binding = BINDING_HTTP_POST
else:
_binding = req.message.protocol_binding
resp_args = self.response_args(req.message, [_binding])
identity = {
"surName": "Example",
"givenName": "Test",
"title": "Ind",
"mail": "[email protected]",
}
resp_args.update({"sign_assertion": True, "sign_response": True})
authn_resp = self.create_authn_response(
identity, userid=identity.get("mail"), authn=AUTHN, **resp_args
)
_dict = pack.factory(
_binding, authn_resp, resp_args["destination"], relay_state, "SAMLResponse"
)
return DummyResponse(**_dict)
| 29.542169 | 4,904 |
1,281 |
py
|
PYTHON
|
15.0
|
# Copyright (C) 2022 XCG Consulting <https://xcg-consulting.fr/>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import api, fields, models
class ResUserSaml(models.Model):
_name = "res.users.saml"
_description = "User to SAML Provider Mapping"
user_id = fields.Many2one("res.users", index=True, required=True)
saml_provider_id = fields.Many2one(
"auth.saml.provider", string="SAML Provider", index=True
)
saml_uid = fields.Char("SAML User ID", help="SAML Provider user_id", required=True)
saml_access_token = fields.Char(
"Current SAML token for this user",
required=False,
help="The current SAML token in use",
)
_sql_constraints = [
(
"uniq_users_saml_provider_saml_uid",
"unique(saml_provider_id, saml_uid)",
"SAML UID must be unique per provider",
)
]
@api.model_create_multi
def create(self, vals_list):
"""Creates new records for the res.users.saml model"""
# Redefined to remove password if necessary
result = super().create(vals_list)
if not self.env["res.users"].allow_saml_and_password():
result.mapped("user_id").write({"password": False})
return result
| 35.583333 | 1,281 |
974 |
py
|
PYTHON
|
15.0
|
from odoo import api, fields, models
class AuthSamlAttributeMapping(models.Model):
"""
Attributes to copy from SAML provider on logon, into Odoo
"""
_name = "auth.saml.attribute.mapping"
_description = "SAML2 attribute mapping"
provider_id = fields.Many2one(
"auth.saml.provider",
index=True,
required=True,
)
attribute_name = fields.Char(
string="IDP Response Attribute",
required=True,
)
field_name = fields.Selection(
string="Odoo Field",
selection="_field_name_selection",
required=True,
)
@api.model
def _field_name_selection(self):
user_fields = self.env["res.users"].fields_get().items()
def valid_field(f, d):
return d.get("type") == "char" and not d.get("readonly")
result = [(f, d.get("string")) for f, d in user_fields if valid_field(f, d)]
result.sort(key=lambda r: r[1])
return result
| 26.324324 | 974 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.