How to fix Django OperationalError /admin/auth/user/add/ SAVEPOINT …_x1 does not exist

stephen django

This is a weird one, an error I had never got until I used an external MySQL (Maria) DB Instance with Django.

The steps to recreate this error would be:

  1. As an Admin try and add another user from the admin section

You will get an error like this:

OperationalError /admin/auth/user/add/
error(1305, 'SAVEPOINT s139787825936192_x1 does not exist')

In my case the system had the following attributes:

  • CentOS 7
  • python mysql connecor: mysqlclient
  • django 2.2.15
  • Server version: 5.5.30 (ProxySQL)

According to this stackoverflow post on the subject, it was to do with the MySQL-Python connector.

The answerer recommends using the mysqlclient python package. Thing is...I am using it.

What I Tried

  • Upgrading to django 3
  • Downloading and installing the lastest python MySQL connectors
  • Installing mariadb libs locally on the app server
  • Uninstall mysqlclient package and use pip install PyMySQL
  • Downgrade from mysqlclient==2.0.0. to mysqlclient==1.4.6

What Worked

I moved to using a local database:

Server version: 10.5.4-MariaDB MariaDB Server

Using django-oauth-toolkit for Client credentials Oauth Flow

stephen django, django, OAuth, python, Security

I've been wanting to secure my api - so unidentified and unathorized parties cannot view, update, create or delete data.
This api is internal to the company and will only be used by other services - in other words no end users.
Hence the delegation of authorization need not happen and the services will be authneticating directly with the api.

That is why the Oauth client credentials flow is used - it is for server to server communication. (As far as I know)

There is alot of conflicting information on Oauth but in the RFC6749 on Oauth 2 Client credentials is mentioned:

1.3.4.  Client Credentials

   The client credentials (or other forms of client authentication) can
   be used as an authorization grant when the authorization scope is
   limited to the protected resources under the control of the client,
   or to protected resources previously arranged with the authorization
   server.  Client credentials are used as an authorization grant
   typically when the client is acting on its own behalf (the client is
   also the resource owner) or is requesting access to protected
   resources based on an authorization previously arranged with the
   authorization server.

Nordic API's: Securing the API Stronghold book mentions:

Oauth: It’s for delegation, and delegation only

I agree except when the client is the resource owner in the client credentials instance.
In that case surely there is no delegation?

Should we use it

What is the advantage over a basic auth or token authentication method?

It seems to just be an added step for the client but the key is that the token expires. So if a bad actor gets our token it will not last long before it is of no use.
The client id and secret is the thing that is used to generate tokend for future calling of the api.

Difference between Resource Owner Password Based flow and client Credentials

Django-oauth-tollkit provides both and their example uses the resource owner password based flow.
In both cases the resource owner is the client - so there is no delegation.

So what is the difference?

I checked on stackoverflow, and it turns out I was wrong.

In the resource owner client based way, the resource owner (end user) trusts the client application enough to give it it's username and password.
We don't really want this.

Implementing Client Credentials flow

Since users are not going to use the API and only services/clients will, I want to disable the other authorization flows and disable registering of clients.

I will manage the clients and they will be the resource owners.

So if you follow the information in the django-oauth-toolkit and setting it up for client credentials that should help

Permissions are significantly different from Django Permissions

What I found out durinng testing is that OauthToolkit implements it's own seperate permissions. So if you were wanting to use django model permissions (add, change, view and delete), you don't be able to.

Wait...I spoke too fast.

You can allow this with:

permission_classes = [IsAuthenticatedOrTokenHasScope, DjangoModelPermission]

However that means that you actually have to test with scopes if you expect a client to use it with Oauth and not django auth.

This is the view to use ClientProtectedResourceView

Minio uses the OAuth 2.0 Implicit flow to Auth with OpenIDC

stephen Uncategorized

Minio's web application is a single apge application.

As far as I can tell it is frontend only and works like a single page application.

That is why when setting up the the client for minio on keycloak.
We set implicit flow to True.

In that case there is no authorization code - and no client secret.
After auth the access token is sent to minio on the front channel. Still need to verify this happens in querystring.
Implicit flow was designed for frontend only single page applications and hence no back channel request can be made.

The client does not go through the extra backchannel step of echanging the authorization code for the access token by authenticating with the client id.