Autenticação

Registro de usuário

A configuração padrão para Weblate é usar python-social-auth, um formulário no site para lidar com o registro de novos usuários. Depois de confirmar seu e-mail, um novo usuário pode contribuir ou autenticar usando um dos serviços de terceiros.

Você também pode desativar o registro de novos usuários usando REGISTRATION_OPEN.

As tentativas de autenticação estão sujeitas a Limitação de taxa.

Backends de autenticação

A solução embutida do Django é utilizada para autenticação, incluindo várias opções sociais para o fazer. Utilizando-a, você pode importar o banco de dados de usuários de outros projetos baseados no Django (veja Migrando de Pootle).

Django pode, adicionalmente, ser configurado para autenticar em outros meios também.

Ver também

Configurações de autenticação descreve como configurar a autenticação na imagem oficial do Docker.

Autenticação social

Graças ao Welcome to Python Social Auth’s documentation!, o Weblate tem suporte a autenticação utilizando muitos serviços de terceiros, tais como GitLab, Ubuntu, Fedora etc.

Por favor, verifique sua documentação para as instruções de configuração genéricas em Django Framework.

Nota

Por padrão, o Weblate conta com serviços de autenticação de terceiros para fornecer um endereço de e-mail validado. Se alguns dos serviços que você deseja usar não suportarem isso, por favor, aplique a validação de e-mail no lado Weblate configurando FORCE_EMAIL_VALIDATION para eles. Por exemplo:

SOCIAL_AUTH_OPENSUSE_FORCE_EMAIL_VALIDATION = True

Ver também

Pipeline

Permitir backends individuais é bastante fácil, é apenas uma questão de adicionar uma entrada à configuração AUTHENTICATION_BACKENDS e possivelmente adicionar chaves necessárias para um determinado método de autenticação. Por favor, note que alguns backends não fornecem e-mails do usuário por padrão, você tem que solicitá-lo explicitamente, caso contrário o Weblate não será capaz de pagar corretamente as contribuições que os usuários fazem.

Dica

A maioria dos backends de autenticação exige HTTPS. Assim que o HTTPS estiver habilitado em seu servidor web, configure o Weblate para relatá-lo corretamente usando ENABLE_HTTPS ou, no contêiner Docker, WEBLATE_ENABLE_HTTPS.

Autenticação por OpenID

Para serviços baseados em OpenID, geralmente é apenas uma questão de habilitá-los. A seção a seguir permite a autenticação OpenID para OpenSUSE, Fedora e Ubuntu:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.email.EmailAuth",
    "social_core.backends.suse.OpenSUSEOpenId",
    "social_core.backends.ubuntu.UbuntuOpenId",
    "social_core.backends.fedora.FedoraOpenId",
    "weblate.accounts.auth.WeblateUserBackend",
)

Ver também

OpenID

Autenticação por GitHub

Você precisa registrar um aplicativo OAuth no GitHub e, em seguida, dizer ao Weblate todos os seus segredos:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.github.GithubOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITHUB_KEY = "GitHub Client ID"
SOCIAL_AUTH_GITHUB_SECRET = "GitHub Client Secret"
SOCIAL_AUTH_GITHUB_SCOPE = ["user:email"]

O GitHub deve ser configurado para ter URL de um retorno de chamada como https://WEBLATE SERVER/accounts/complete/github/.

Existem backends de autenticação semelhantes para o GitHub para Organizações e o GitHub para Equipes. Suas configurações são denominadas SOCIAL_AUTH_GITHUB_ORG_* e SOCIAL_AUTH_GITHUB_TEAM_*, e requerem configuração adicional do escopo – SOCIAL_AUTH_GITHUB_ORG_NAME ou SOCIAL_AUTH_GITHUB_TEAM_ID. Seus URLs de retorno de chamada são https://WEBLATE SERVER/accounts/complete/github-org/ e https://WEBLATE SERVER/accounts/complete/github-teams/.

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

GitHub

Autenticação por GitHub EE

Você precisa registrar um aplicativo OAuth no GitHub EE e, em seguida, informar ao Weblate todos as suas chaves secretas:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.github_enterprise.GithubEnterpriseOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITHUB_ENTERPRISE_KEY = "GitHub OAuth App Client ID"
SOCIAL_AUTH_GITHUB_ENTERPRISE_SECRET = "GitHub OAuth App Client Secret"
SOCIAL_AUTH_GITHUB_ENTERPRISE_URL = "https://git.example.com/"
SOCIAL_AUTH_GITHUB_ENTERPRISE_API_URL = "https://git.example.com/api/v3/"
SOCIAL_AUTH_GITHUB_ENTERPRISE_SCOPE = ["user:email"]

The GitHub OAuth App should be configured to have callback URL as https://WEBLATE SERVER/accounts/complete/github-enterprise/.

Instead GitHub OAuth App, GitHub App can also be used. With GitHub App permissions can be granted on repositories, organisation and/or user level. If you decide to use GitHub App, you need to enable Access: Read-only permission for Users - <Email addresses> and Organisation - <Members>.

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

GitHub Enterprise

Autenticação por Bitbucket

Você precisa registrar um aplicativo no Bitbucket e, em seguida, dizer ao Weblate todos os seus segredos:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.bitbucket.BitbucketOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_BITBUCKET_OAUTH2_KEY = "Bitbucket Client ID"
SOCIAL_AUTH_BITBUCKET_OAUTH2_SECRET = "Bitbucket Client Secret"
SOCIAL_AUTH_BITBUCKET_OAUTH2_VERIFIED_EMAILS_ONLY = True

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Bitbucket

Google OAuth 2

Para usar o OAuth 2 do Google, você precisa se registrar em um aplicativo em <https://console.developers.google.com/> e ativar a API do Google+.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/google-oauth2/

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.google.GoogleOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GOOGLE_OAUTH2_KEY = "Client ID"
SOCIAL_AUTH_GOOGLE_OAUTH2_SECRET = "Client secret"

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Google

OAuth 2 do Facebook

Como de costume com os serviços OAuth 2, você precisa registrar seu aplicativo no Facebook. Uma vez feito isso, você pode configurar o Weblate para usá-lo:

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/facebook/

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.facebook.FacebookOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_FACEBOOK_KEY = "key"
SOCIAL_AUTH_FACEBOOK_SECRET = "secret"
SOCIAL_AUTH_FACEBOOK_SCOPE = ["email", "public_profile"]

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Facebook

OAuth 2 do GitLab

Para usar o OAuth 2 do GitLab, você precisa registrar um aplicativo em <https://gitlab.com/profile/applications>.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/gitlab/ e garantir que você marque o escopo read_user.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.gitlab.GitLabOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_GITLAB_KEY = "Application ID"
SOCIAL_AUTH_GITLAB_SECRET = "Secret"
SOCIAL_AUTH_GITLAB_SCOPE = ["read_user"]

# If you are using your own GitLab
# SOCIAL_AUTH_GITLAB_API_URL = 'https://gitlab.example.com/'

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

GitLab

Active Directory do Microsoft Azure

Weblate pode ser configurado para usar inquilinos comuns ou específicos para autenticação.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/azuread-oauth2/ para autenticação comum e https://SERVIDOR WEBLATE/accounts/complete/azuread-tenant-oauth2/ para autenticação específica do inquilino.

Você precisará do seguinte:

  • A ID do Aplicativo (cliente) pode ser obtida na página do aplicativo. A ID do Objeto não é usado no Weblate.

  • A ID do Diretório (locatário) é necessária para a autenticação com escopo de locatário, o que geralmente é desejado.

  • O Valor do Segredo é exibido quando você gera um segredo para um aplicativo. A ID do Segredo não é usado no Weblate.

# Azure AD common

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.azuread.AzureADOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# OAuth2 keys
SOCIAL_AUTH_AZUREAD_OAUTH2_KEY = ""
SOCIAL_AUTH_AZUREAD_OAUTH2_SECRET = ""
# Azure AD Tenant

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.azuread_tenant.AzureADTenantOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Application (client) ID
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_KEY = ""
# Secret value
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_SECRET = ""
# Directory (tenant) ID
SOCIAL_AUTH_AZUREAD_TENANT_OAUTH2_TENANT_ID = ""

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Slack

Para usar o OAuth 2 do Slack, você precisa cadastrar um aplicativo em <https://api.slack.com/apps>.

A URL de redirecionamento é https://SERVIDOR WEBLATE/accounts/complete/slack/.

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.slack.SlackOAuth2",
    "social_core.backends.email.EmailAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_SLACK_KEY = ""
SOCIAL_AUTH_SLACK_SECRET = ""

Nota

O Weblate fornecia URL de retorno de chamada durante a autenticação inclui domínio configurado. No caso de você obter erros sobre incompatibilidade de URL, você pode querer corrigir isso, consulte Definir domínio correto do site.

Ver também

Slack

Substituindo nomes e ícones de métodos de autenticação

Você pode substituir o nome de exibição do método de autenticação e o ícone usando configurações como SOCIAL_AUTH_<NOME>_IMAGE e SOCIAL_AUTH_<NOME>_TITLE. Por exemplo, substituir a nomenclatura para Auth0 ficaria assim:

SOCIAL_AUTH_AUTH0_IMAGE = "custom.svg"
SOCIAL_AUTH_AUTH0_TITLE = "Custom auth"

Desativando autenticação por senha

Autenticação por e-mail e senha pode ser desativada através da remoção de social_core.backends.email.EmailAuth de AUTHENTICATION_BACKENDS. Mantenha sempre weblate.accounts.auth.WeblateUserBackend lá, ele é necessário para a funcionalidade central do Weblate.

Desabilitar a autenticação por e-mail desabilitará todas as funcionalidades relacionadas a e-mail – convite a usuários ou recurso de redefinição de senha.

Dica

Você ainda pode usar autenticação por senha para a interface administrativa, para usuários que você cria manualmente lá. Basta navegar para /admin/login/.

Por exemplo, a autenticação usando apenas o provedor Open ID do openSUSE pode ser alcançada usando o seguinte:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.suse.OpenSUSEOpenId",
    "weblate.accounts.auth.WeblateUserBackend",
)

Autenticação por senha

O settings.py padrão vem com um razoável conjunto de AUTH_PASSWORD_VALIDATORS:

  • As senhas não podem ser muito similares às suas outras informações pessoais.

  • As senhas devem conter no mínimo 10 caracteres.

  • As senhas não podem ser uma senha comumente usada.

  • As senhas não podem ser inteiramente numéricas.

  • As senhas não podem consistir em um único caractere ou apenas espaço em branco.

  • As senhas não podem corresponder a uma senha que você usou no passado.

Você pode personalizar esta configuração para corresponder à sua política de senha.

Além disso, você também pode instalar o django-zxcvbn-password o que dá bastante estimativas realistas de senha dificuldade e permite rejeitar senhas abaixo de um determinado limite.

Autenticação por SAML

Adicionado na versão 4.1.1.

Siga as instruções do Python Social Auth para configuração. Diferenças notáveis:

  • Weblate tem suporte a único IDP que tem de ser chamado de weblate em SOCIAL_AUTH_SAML_ENABLED_IDPS.

  • A URL de metadados XML de SAML é /accounts/metadata/saml/.

  • As configurações a seguir são preenchidas automaticamente: SOCIAL_AUTH_SAML_SP_ENTITY_ID, SOCIAL_AUTH_SAML_TECHNICAL_CONTACT, SOCIAL_AUTH_SAML_SUPPORT_CONTACT

Exemplo de configuração:

# Authentication configuration
AUTHENTICATION_BACKENDS = (
    "social_core.backends.email.EmailAuth",
    "social_core.backends.saml.SAMLAuth",
    "weblate.accounts.auth.WeblateUserBackend",
)

# Social auth backends setup
SOCIAL_AUTH_SAML_SP_ENTITY_ID = f"https://{SITE_DOMAIN}/accounts/metadata/saml/"
SOCIAL_AUTH_SAML_SP_PUBLIC_CERT = "-----BEGIN CERTIFICATE-----"
SOCIAL_AUTH_SAML_SP_PRIVATE_KEY = "-----BEGIN PRIVATE KEY-----"
SOCIAL_AUTH_SAML_ENABLED_IDPS = {
    "weblate": {
        "entity_id": "https://idp.testshib.org/idp/shibboleth",
        "url": "https://idp.testshib.org/idp/profile/SAML2/Redirect/SSO",
        "x509cert": "MIIEDjCCAvagAwIBAgIBADA ... 8Bbnl+ev0peYzxFyF5sQA==",
        "attr_name": "full_name",
        "attr_username": "username",
        "attr_email": "email",
    }
}
SOCIAL_AUTH_SAML_ORG_INFO = {
    "en-US": {
        "name": "example",
        "displayname": "Example Inc.",
        "url": "http://example.com"
    }
}
SOCIAL_AUTH_SAML_TECHNICAL_CONTACT = {
    "givenName": "Tech Gal",
    "emailAddress": "technical@example.com"
}
SOCIAL_AUTH_SAML_SUPPORT_CONTACT = {
    "givenName": "Support Guy",
    "emailAddress": "support@example.com"
}

A configuração padrão extrai detalhes do usuário dos seguintes atributos, configure seu IDP para fornecê-los:

Atributo

Referência de URI SAML

Nome completo

urn:oid:2.5.4.3

Primeiro nome

urn:oid:2.5.4.42

Sobrenome

urn:oid:2.5.4.4

E-mail

urn:oid:0.9.2342.19200300.100.1.3

Nome de usuário

urn:oid:0.9.2342.19200300.100.1.1

Dica

O exemplo acima e a imagem do Docker definem um IDP chamado weblate. Pode ser preciso configurar este texto como Relay em seu IDP.

Autenticação por LDAP

A autenticação por LDAP pode ser melhor alcançada utilizando o pacote django-auth-ldap. Você pode instalá-lo através dos meios habituais:

# Using PyPI
pip install 'django-auth-ldap>=1.3.0'

# Using apt-get
apt-get install python-django-auth-ldap

Dica

Este pacote está incluído no contêiner Docker, veja Instalando usando Docker.

Nota

Há algumas incompatibilidades no módulo Python LDAP 3.1.0, o que pode impedir você de usar essa versão. Se você obter o erro AttributeError: ‘module’ object has no attribute ‘_trace_level’, fazer o downgrade para python-ldap 3.0.0 pode ajudar.

Uma vez que você tenha o pacote instalado, você pode conectá-lo à autenticação do Django:

# Add LDAP backed, keep Django one if you want to be able to sign in
# even without LDAP for admin account
AUTHENTICATION_BACKENDS = (
    "django_auth_ldap.backend.LDAPBackend",
    "weblate.accounts.auth.WeblateUserBackend",
)

# LDAP server address
AUTH_LDAP_SERVER_URI = "ldaps://ldap.example.net"

# DN to use for authentication
AUTH_LDAP_USER_DN_TEMPLATE = "cn=%(user)s,o=Example"
# Depending on your LDAP server, you might use a different DN
# like:
# AUTH_LDAP_USER_DN_TEMPLATE = 'ou=users,dc=example,dc=com'

# List of attributes to import from LDAP upon sign in
# Weblate stores full name of the user in the full_name attribute
AUTH_LDAP_USER_ATTR_MAP = {
    "full_name": "name",
    # Use the following if your LDAP server does not have full name
    # Weblate will merge them later
    # 'first_name': 'givenName',
    # 'last_name': 'sn',
    # Email is required for Weblate (used in VCS commits)
    "email": "mail",
}

# Hide the registration form
REGISTRATION_OPEN = False

Nota

You should remove 'social_core.backends.email.EmailAuth' from the AUTHENTICATION_BACKENDS setting, otherwise users will be able to set their password in Weblate, and authenticate using that. Keeping 'weblate.accounts.auth.WeblateUserBackend' is still needed in order to make permissions and facilitate anonymous users. It will also allow you to sign in using a local admin account, if you have created it (e.g. by using createadmin).

Usando senha associada

Se você não puder usar associação direta para autenticação, você precisará usar a pesquisa e fornecer um usuário para associar à pesquisa. Por exemplo:

import ldap
from django_auth_ldap.config import LDAPSearch

AUTH_LDAP_BIND_DN = ""
AUTH_LDAP_BIND_PASSWORD = ""
AUTH_LDAP_USER_SEARCH = LDAPSearch(
    "ou=users,dc=example,dc=com", ldap.SCOPE_SUBTREE, "(uid=%(user)s)"
)

Integração com Active Directory

import ldap
from django_auth_ldap.config import LDAPSearch, NestedActiveDirectoryGroupType

AUTH_LDAP_BIND_DN = "CN=ldap,CN=Users,DC=example,DC=com"
AUTH_LDAP_BIND_PASSWORD = "password"

# User and group search objects and types
AUTH_LDAP_USER_SEARCH = LDAPSearch(
    "CN=Users,DC=example,DC=com", ldap.SCOPE_SUBTREE, "(sAMAccountName=%(user)s)"
)

# Make selected group a superuser in Weblate
AUTH_LDAP_USER_FLAGS_BY_GROUP = {
    # is_superuser means user has all permissions
    "is_superuser": "CN=weblate_AdminUsers,OU=Groups,DC=example,DC=com",
}

# Map groups from AD to Weblate
AUTH_LDAP_GROUP_SEARCH = LDAPSearch(
    "OU=Groups,DC=example,DC=com", ldap.SCOPE_SUBTREE, "(objectClass=group)"
)
AUTH_LDAP_GROUP_TYPE = NestedActiveDirectoryGroupType()
AUTH_LDAP_FIND_GROUP_PERMS = True

# Optionally enable group mirroring from LDAP to Weblate
# AUTH_LDAP_MIRROR_GROUPS = True

Autenticação por CAS

A autenticação por CAS pode ser alcançada usando um pacote como o django-cas-ng.

O primeiro passo é divulgar o campo de e-mail do usuário via CAS. Isso tem que ser configurado no próprio servidor CAS, e requer que você execute pelo menos CAS v2, já que o CAS v1 não tem suporte a atributos.

O segundo passo é atualizar o Weblate para utilizar o seu servidor CAS e os seus atributos.

Para instalar django-cas-ng:

pip install django-cas-ng

Uma vez que o pacote instalado, você pode conectá-lo ao sistema de autenticação do Django modificando o arquivo settings.py:

# Add CAS backed, keep the Django one if you want to be able to sign in
# even without LDAP for the admin account
AUTHENTICATION_BACKENDS = (
    "django_cas_ng.backends.CASBackend",
    "weblate.accounts.auth.WeblateUserBackend",
)

# CAS server address
CAS_SERVER_URL = "https://cas.example.net/cas/"

# Add django_cas_ng somewhere in the list of INSTALLED_APPS
INSTALLED_APPS = (..., "django_cas_ng")

Finalmente, um sinal pode ser usado para mapear o campo de e-mail para o objeto do usuário. Para que isso funcione, você tem que importar o sinal do pacote django-cas-ng e conectar seu código com este sinal. Fazer isso em configurações de arquivo pode causar problemas, portanto, é sugerido colocá-lo:

from django_cas_ng.signals import cas_user_authenticated
from django.dispatch import receiver


@receiver(cas_user_authenticated)
def update_user_email_address(sender, user=None, attributes=None, **kwargs):
    # If your CAS server does not always include the email attribute
    # you can wrap the next two lines of code in a try/catch block.
    user.email = attributes["email"]
    user.save()

Ver também

Django CAS NG

Configurando autenticação por Django de terceiros

Geralmente, qualquer plugin de autenticação Django deve funcionar com Weblate. Basta seguir as instruções do plugin, lembrando de manter o backend do usuário Weblate instalado.

Normalmente, a instalação consiste em adicionar uma autenticação de backend a AUTHENTICATION_BACKENDS e a instalar um aplicativo de autenticação (se houver) no INSTALLED_APPS:

AUTHENTICATION_BACKENDS = (
    # Add authentication backend here
    "weblate.accounts.auth.WeblateUserBackend",
)

INSTALLED_APPS += (
    # Install authentication app here
)