Quelle est la méthode standard pour générer un nonce en Python?

Quelqu'un peut-il partager les meilleures pratiques pour la création d'un nonce pour OAuth demande en Python?

source d'informationauteur charliesneath

  1. 5

    Voici comment python-oauth2:

    def generate_nonce(length=8):
    """Generate pseudorandom number."""
    return ''.join([str(random.randint(0, 9)) for i in range(length)])

    Ils ont aussi:

    @classmethod
def make_nonce(cls):
    """Generate pseudorandom number."""
    return str(random.randint(0, 100000000))

    En outre, il est cette question intitulée: "make_nonce n'est pas suffisamment aléatoire", qui propose:

    def gen_nonce(length):
   """ Generates a random string of bytes, base64 encoded """
   if length < 1:
      return ''
   string=base64.b64encode(os.urandom(length),altchars=b'-_')
   b64len=4*floor(length,3)
   if length%3 == 1:
      b64len+=2
   elif length%3 == 2:
      b64len+=3
   return string[0:b64len].decode()

    Et aussi les références CVE-2013-4347. TL;DR version, utilisez os.urandom ou l'abstraction de l'interface (SystemRandom).

    J'aime mon lambdas—et ne veulent pas les caractères non-alphanumériques—j'ai donc utilisé ce:

    lambda length: filter(lambda s: s.isalpha(), b64encode(urandom(length * 2)))[:length]
  2. 4

    Voici ce que rauth. Il n'y a pas vraiment de règles strictes et rapides ici. La spec ne semble pas trop opiniâtre. Votre la contrainte de la valeur, d'être un nonce, doit être unique. Autres que que, en supposant que le fournisseur ne se plaint pas, vous pouvez utiliser quelle que soit la méthode que vous aimez.

  3. 4

    Nonce doit être à la fois utilisé qu'une seule fois et difficile de prédire:

    import uuid

uuid.uuid4().hex
# '12b90b6ffc0e46f788a26f1a6dc246fc'

    uuid4() utilise os.urandom() qui est le mieux aléatoires que vous pouvez obtenir en python.

    Noter que uuid4() est plus difficile à prévoir que uuid1() tandis que plus tard est plus unique au monde. Vous pouvez concaténer les deux pour atteindre ces deux objectifs:

    uuid.uuid4().hex + uuid.uuid1().hex
# 'a6d68f4d81ec440fb3d5ef6416079305f7a44a0c9e9011e684e2c42c0319303d'
  4. 1

    Ici sont quelques idées que j'ai pour l'emailage. Le generate_nonce vient de leur code, mais j'utilise generate_nonce_timestamp que j'ai utilisé uuid. Il me donne un hasard chaîne alphanumérique et un timbre de temps en secondes:

    import random
import time
import uuid


def generate_nonce(length=8):
    """Generate pseudo-random number."""
    return ''.join([str(random.randint(0, 9)) for i in range(length)])


def generate_timestamp():
    """Get seconds since epoch (UTC)."""
    return str(int(time.time()))

def generate_nonce_timestamp():
    """Generate pseudo-random number and seconds since epoch (UTC)."""
    nonce = uuid.uuid1()
    oauth_timestamp, oauth_nonce = str(nonce.time), nonce.hex
    return oauth_nonce, oauth_timestamp

    J'aime utiliser uuid1, puisqu'il produit de l'uuid, sur la base actuelle de l'hôte et de l'heure et a la propriété de temps que vous pouvez extraire si vous avez besoin de deux. Pour emailage, vous avez besoin de l'horodatage et le nonce.

    Ici est ce que vous obtenez:

    >>> generate_nonce_timestamp()
('a89faa84-6c35-11e5-8a36-080027c336f0', '136634341422770820')

    Si vous souhaitez supprimer le -utilisez nonce.get_hex().

    uuid1 - Générer un UUID à partir d'un ID d'hôte, le numéro de séquence, et à l'heure actuelle.
    Plus sur uuid.