HTTP Basic Auth

Warning

The current page still doesn’t have a translation for this language.

But you can help translating it: Contributing.

For the simplest cases, you can use HTTP Basic Auth.

In HTTP Basic Auth, the application expects a header that contains a username and a password.

If it doesn’t receive it, it returns an HTTP 401 “Unauthorized” error.

And returns a header WWW-Authenticate with a value of Basic, and an optional realm parameter.

That tells the browser to show the integrated prompt for a username and password.

Then, when you type that username and password, the browser sends them in the header automatically.

Simple HTTP Basic Auth

  • Import HTTPBasic and HTTPBasicCredentials.
  • Create a “security scheme” using HTTPBasic.
  • Use that security with a dependency in your path operation.
  • It returns an object of type HTTPBasicCredentials:
    • It contains the username and password sent.

Python 3.6+Python 3.6+ non-Annotated

  1. from typing import Annotated
  3. from fastapi import Depends, FastAPI
  4. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  6. app = FastAPI()
  8. security = HTTPBasic()
  11. @app.get("/users/me")
  12. def read_current_user(credentials: Annotated[HTTPBasicCredentials, Depends(security)]):
  13.     return {"username": credentials.username, "password": credentials.password}
  1. from fastapi import Depends, FastAPI
  2. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  3. from typing_extensions import Annotated
  5. app = FastAPI()
  7. security = HTTPBasic()
  10. @app.get("/users/me")
  11. def read_current_user(credentials: Annotated[HTTPBasicCredentials, Depends(security)]):
  12.     return {"username": credentials.username, "password": credentials.password}

Tip

Prefer to use the Annotated version if possible.

  1. from fastapi import Depends, FastAPI
  2. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  4. app = FastAPI()
  6. security = HTTPBasic()
  9. @app.get("/users/me")
  10. def read_current_user(credentials: HTTPBasicCredentials = Depends(security)):
  11.     return {"username": credentials.username, "password": credentials.password}

When you try to open the URL for the first time (or click the “Execute” button in the docs) the browser will ask you for your username and password:

HTTP Basic Auth - 图1

Check the username

Here’s a more complete example.

Use a dependency to check if the username and password are correct.

For this, use the Python standard module secrets to check the username and password.

secrets.compare_digest() needs to take bytes or a str that only contains ASCII characters (the ones in English), this means it wouldn’t work with characters like á, as in Sebastián.

To handle that, we first convert the username and password to bytes encoding them with UTF-8.

Then we can use secrets.compare_digest() to ensure that credentials.username is "stanleyjobson", and that credentials.password is "swordfish".

Python 3.9+Python 3.6+Python 3.6+ non-Annotated

  1. import secrets
  2. from typing import Annotated
  4. from fastapi import Depends, FastAPI, HTTPException, status
  5. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  7. app = FastAPI()
  9. security = HTTPBasic()
  12. def get_current_username(
  13.     credentials: Annotated[HTTPBasicCredentials, Depends(security)]
  14. ):
  15.     current_username_bytes = credentials.username.encode("utf8")
  16.     correct_username_bytes = b"stanleyjobson"
  17.     is_correct_username = secrets.compare_digest(
  18.         current_username_bytes, correct_username_bytes
  19.     )
  20.     current_password_bytes = credentials.password.encode("utf8")
  21.     correct_password_bytes = b"swordfish"
  22.     is_correct_password = secrets.compare_digest(
  23.         current_password_bytes, correct_password_bytes
  24.     )
  25.     if not (is_correct_username and is_correct_password):
  26.         raise HTTPException(
  27.             status_code=status.HTTP_401_UNAUTHORIZED,
  28.             detail="Incorrect email or password",
  29.             headers={"WWW-Authenticate": "Basic"},
  30.         )
  31.     return credentials.username
  34. @app.get("/users/me")
  35. def read_current_user(username: Annotated[str, Depends(get_current_username)]):
  36.     return {"username": username}
  1. import secrets
  3. from fastapi import Depends, FastAPI, HTTPException, status
  4. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  5. from typing_extensions import Annotated
  7. app = FastAPI()
  9. security = HTTPBasic()
  12. def get_current_username(
  13.     credentials: Annotated[HTTPBasicCredentials, Depends(security)]
  14. ):
  15.     current_username_bytes = credentials.username.encode("utf8")
  16.     correct_username_bytes = b"stanleyjobson"
  17.     is_correct_username = secrets.compare_digest(
  18.         current_username_bytes, correct_username_bytes
  19.     )
  20.     current_password_bytes = credentials.password.encode("utf8")
  21.     correct_password_bytes = b"swordfish"
  22.     is_correct_password = secrets.compare_digest(
  23.         current_password_bytes, correct_password_bytes
  24.     )
  25.     if not (is_correct_username and is_correct_password):
  26.         raise HTTPException(
  27.             status_code=status.HTTP_401_UNAUTHORIZED,
  28.             detail="Incorrect email or password",
  29.             headers={"WWW-Authenticate": "Basic"},
  30.         )
  31.     return credentials.username
  34. @app.get("/users/me")
  35. def read_current_user(username: Annotated[str, Depends(get_current_username)]):
  36.     return {"username": username}

Tip

Prefer to use the Annotated version if possible.

  1. import secrets
  3. from fastapi import Depends, FastAPI, HTTPException, status
  4. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  6. app = FastAPI()
  8. security = HTTPBasic()
  11. def get_current_username(credentials: HTTPBasicCredentials = Depends(security)):
  12.     current_username_bytes = credentials.username.encode("utf8")
  13.     correct_username_bytes = b"stanleyjobson"
  14.     is_correct_username = secrets.compare_digest(
  15.         current_username_bytes, correct_username_bytes
  16.     )
  17.     current_password_bytes = credentials.password.encode("utf8")
  18.     correct_password_bytes = b"swordfish"
  19.     is_correct_password = secrets.compare_digest(
  20.         current_password_bytes, correct_password_bytes
  21.     )
  22.     if not (is_correct_username and is_correct_password):
  23.         raise HTTPException(
  24.             status_code=status.HTTP_401_UNAUTHORIZED,
  25.             detail="Incorrect email or password",
  26.             headers={"WWW-Authenticate": "Basic"},
  27.         )
  28.     return credentials.username
  31. @app.get("/users/me")
  32. def read_current_user(username: str = Depends(get_current_username)):
  33.     return {"username": username}

This would be similar to:

  1. if not (credentials.username == "stanleyjobson") or not (credentials.password == "swordfish"):
  2.     # Return some error
  3.     ...

But by using the secrets.compare_digest() it will be secure against a type of attacks called “timing attacks”.

Timing Attacks

But what’s a “timing attack”?

Let’s imagine some attackers are trying to guess the username and password.

And they send a request with a username johndoe and a password love123.

Then the Python code in your application would be equivalent to something like:

  1. if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
  2.     ...

But right at the moment Python compares the first j in johndoe to the first s in stanleyjobson, it will return False, because it already knows that those two strings are not the same, thinking that “there’s no need to waste more computation comparing the rest of the letters”. And your application will say “incorrect user or password”.

But then the attackers try with username stanleyjobsox and password love123.

And your application code does something like:

  1. if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
  2.     ...

Python will have to compare the whole stanleyjobso in both stanleyjobsox and stanleyjobson before realizing that both strings are not the same. So it will take some extra microseconds to reply back “incorrect user or password”.

The time to answer helps the attackers

At that point, by noticing that the server took some microseconds longer to send the “incorrect user or password” response, the attackers will know that they got something right, some of the initial letters were right.

And then they can try again knowing that it’s probably something more similar to stanleyjobsox than to johndoe.

A “professional” attack

Of course, the attackers would not try all this by hand, they would write a program to do it, possibly with thousands or millions of tests per second. And would get just one extra correct letter at a time.

But doing that, in some minutes or hours the attackers would have guessed the correct username and password, with the “help” of our application, just using the time taken to answer.

Fix it with secrets.compare_digest()

But in our code we are actually using secrets.compare_digest().

In short, it will take the same time to compare stanleyjobsox to stanleyjobson than it takes to compare johndoe to stanleyjobson. And the same for the password.

That way, using secrets.compare_digest() in your application code, it will be safe against this whole range of security attacks.

Return the error

After detecting that the credentials are incorrect, return an HTTPException with a status code 401 (the same returned when no credentials are provided) and add the header WWW-Authenticate to make the browser show the login prompt again:

Python 3.9+Python 3.6+Python 3.6+ non-Annotated

  1. import secrets
  2. from typing import Annotated
  4. from fastapi import Depends, FastAPI, HTTPException, status
  5. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  7. app = FastAPI()
  9. security = HTTPBasic()
  12. def get_current_username(
  13.     credentials: Annotated[HTTPBasicCredentials, Depends(security)]
  14. ):
  15.     current_username_bytes = credentials.username.encode("utf8")
  16.     correct_username_bytes = b"stanleyjobson"
  17.     is_correct_username = secrets.compare_digest(
  18.         current_username_bytes, correct_username_bytes
  19.     )
  20.     current_password_bytes = credentials.password.encode("utf8")
  21.     correct_password_bytes = b"swordfish"
  22.     is_correct_password = secrets.compare_digest(
  23.         current_password_bytes, correct_password_bytes
  24.     )
  25.     if not (is_correct_username and is_correct_password):
  26.         raise HTTPException(
  27.             status_code=status.HTTP_401_UNAUTHORIZED,
  28.             detail="Incorrect email or password",
  29.             headers={"WWW-Authenticate": "Basic"},
  30.         )
  31.     return credentials.username
  34. @app.get("/users/me")
  35. def read_current_user(username: Annotated[str, Depends(get_current_username)]):
  36.     return {"username": username}
  1. import secrets
  3. from fastapi import Depends, FastAPI, HTTPException, status
  4. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  5. from typing_extensions import Annotated
  7. app = FastAPI()
  9. security = HTTPBasic()
  12. def get_current_username(
  13.     credentials: Annotated[HTTPBasicCredentials, Depends(security)]
  14. ):
  15.     current_username_bytes = credentials.username.encode("utf8")
  16.     correct_username_bytes = b"stanleyjobson"
  17.     is_correct_username = secrets.compare_digest(
  18.         current_username_bytes, correct_username_bytes
  19.     )
  20.     current_password_bytes = credentials.password.encode("utf8")
  21.     correct_password_bytes = b"swordfish"
  22.     is_correct_password = secrets.compare_digest(
  23.         current_password_bytes, correct_password_bytes
  24.     )
  25.     if not (is_correct_username and is_correct_password):
  26.         raise HTTPException(
  27.             status_code=status.HTTP_401_UNAUTHORIZED,
  28.             detail="Incorrect email or password",
  29.             headers={"WWW-Authenticate": "Basic"},
  30.         )
  31.     return credentials.username
  34. @app.get("/users/me")
  35. def read_current_user(username: Annotated[str, Depends(get_current_username)]):
  36.     return {"username": username}

Tip

Prefer to use the Annotated version if possible.

  1. import secrets
  3. from fastapi import Depends, FastAPI, HTTPException, status
  4. from fastapi.security import HTTPBasic, HTTPBasicCredentials
  6. app = FastAPI()
  8. security = HTTPBasic()
  11. def get_current_username(credentials: HTTPBasicCredentials = Depends(security)):
  12.     current_username_bytes = credentials.username.encode("utf8")
  13.     correct_username_bytes = b"stanleyjobson"
  14.     is_correct_username = secrets.compare_digest(
  15.         current_username_bytes, correct_username_bytes
  16.     )
  17.     current_password_bytes = credentials.password.encode("utf8")
  18.     correct_password_bytes = b"swordfish"
  19.     is_correct_password = secrets.compare_digest(
  20.         current_password_bytes, correct_password_bytes
  21.     )
  22.     if not (is_correct_username and is_correct_password):
  23.         raise HTTPException(
  24.             status_code=status.HTTP_401_UNAUTHORIZED,
  25.             detail="Incorrect email or password",
  26.             headers={"WWW-Authenticate": "Basic"},
  27.         )
  28.     return credentials.username
  31. @app.get("/users/me")
  32. def read_current_user(username: str = Depends(get_current_username)):
  33.     return {"username": username}