CRC32 ferait l'affaire si vous n'avez pas besoin de sécurité cryptographique. Il vous donne une valeur de sortie 32 bits et ne nécessite que des opérations simples. De nombreuses implémentations sont également disponibles pour la plupart des grandes micro-familles. Divisez en 4 octets et faites un module sur un alphabet de 32 caractères (1-9 A-Z, en sautant quelques caractères comme I et J) pour chacun, et voici votre code.

Dans quelle mesure voulez-vous que cette chose soit sécurisée et quelle est la taille de votre code par rapport aux compromis d'espace? Allez-vous avoir besoin uniquement de nombres séquentiels ou de valeurs dans une séquence arbitraire?

Deux approches simples de génération de hachage sont: // Obtenir un bit aléatoire via un générateur congruentiel linéaire: int random_bit1 (void) {static unsigned longue graine; graine = graine * magicConstant + 12345; retour (graine >> 31); // Utilisez le bit supérieur - pas le bit inférieur! }

  int random_bit2 (void) {// Obtient un bit 'aléatoire' via un registre à décalage linéaire non signé avec un long shifter; if (! shifter) shifter = 1; else if (shifter & 1) shifter = (shifter>>1); else shifter = (shifter>>1); return (shifter & 1);}  

Pour générer un nombre à quatre chiffres, utilisez quelque chose comme ce qui suit:

  int result = 0; int i; for (i = 0; i<30; i ++) // Plus le nombre est élevé, moins les résultats sont biaisés {result * = 2; si (résultat > = 10000) résultat - = 10000; result + = randomBit ();}  

Notez que les deux algorithmes de génération de bits ci-dessus peuvent être adaptés pour renvoyer la nième valeur pour tout n arbitraire dans un laps de temps raisonnable, bien que le code pour faire cela sera un peu plus compliqué. D'un autre côté, aucun des deux algorithmes ne sera difficile à rétroconcevoir.

Si vous n'avez besoin que de valeurs en séquence (ce qui signifie qu'après avoir produit la nième chose, vous n'aurez jamais besoin pour produire n'importe quelle chose de numéro inférieur, et cela ne vous dérangera pas si le calcul d'une chose de numéro plus élevé nécessite le calcul de toutes les valeurs intermédiaires), il est possible de renforcer la sécurité en utilisant environ six générateurs de bits pseudo-aléatoires indépendants (peut-être shift registres avec des périodes différentes), puis utilisez quelque chose comme:

  int reallyrandombit (void) {if (randombit1 ()) {if (randombit2 ()) return randombit3 (); sinon retourner randombit4 (); } else {if (randombit3 ())
retourne randombit5 (); sinon retourner randombit6 (); }}  

Notez que pour de bons résultats, il devrait y avoir un certain mélange de la façon dont les générateurs aléatoires sont utilisés (notez que random3 est utilisé à deux endroits différents) mais il faut éviter les chemins de rétroaction (aucun des les générateurs aléatoires affectent le déplacement de tout ce qui l'affecterait) à moins que l'on ne dispose des outils pour les analyser complètement.

Vous pourriez être intéressé par cette bibliothèque Crypto. Il est publié sous la GPL v3.

Crypto-avr-lib est un ensemble d'implémentations de différentes primitives cryptographiques. En raison des limitations particulières des microcontrôleurs (très peu d'espace, la RAM et la mémoire flash vont de quelques octets à quelques Kio), la référence ou les implémentations optimisées «normales» ne sont pas utilisables. Par conséquent, nous essayons de fournir des implémentations spéciales qui respectent les ressources extrêmement limitées des applications de microcontrôleur.

Il existe plusieurs algorithmes de hachage disponibles:

• Blake
• BlueMidnightWish
• Grøstl
• MD5
• SHA-256
• SHA-1
• SHA-3 (Keccak)
• SHABAL
• Skein
• Twister
• Whirlpool

Vous pouvez accéder au code complet via leur référentiel Subversion à http://das-labor.org/svn/microcontroller-2/crypto-lib.

• Si vous ne vous souciez vraiment pas de la sécurité
• Si tout ce que vous voulez faire est de «gâcher» un nombre

Alors il y a un un tas de façons très simples de faire cela, voici deux auxquelles je peux penser:

  void really_simple_hash (uint16_t x) {SWAP_NIBBLES (FIRST_BYTE (x)); SWAP_NIBBLES (SECOND_BYTE (x)); x ^ = 0xAAAA; return x;}  

Sur un PIC18, cela se traduit par du code très simple:

  SWAPF x, fSWAPF x + 1, fmovlw 0xAAxorwf x, fxorwf x +1, f  

C'est assez léger à seulement 5uS de temps d'exécution sur un PIC18 fonctionnant à 10MIPS. Si cela ne suffit pas, vous pouvez mélanger les bits dans le nombre. Encore une fois, sur un PIC18:

  rrcf x, f; Ensuite, nous prenons chaque bit du mot sourcerlcf y + 1, f; et déplacez-le dans l'un des octets de destinationrrcf x + 1, frlcf y, f; Il y a: rrcf x, f; - huit décalages à droite de x, rlcf y + 1, f; - huit décalages à droite de x + 1, rrcf x + 1, f; - huit décalages à gauche de y, rlcf y + 1, f; - huit décalages à gauche de y + 1, rrcf x, frlcf y, f; Vous pouvez les faire dans l'ordre de votre choix: rrcf x + 1, frlcf y, frrcf x, frlcf y + 1, frrcf x, frlcf y, frrcf x, frlcf y, frrcf x, f rlcf y + 1, f rrcf x + 1 , frlcf y, frrcf x, frlcf y + 1, frrcf x + 1, frlcf y + 1, frrcf x, frlcf y, frrcf x + 1, frlcf y, frrcf x, frlcf y + 1, frrcf x, frlcf y, frrcf x, frlcf y, f; Enfin, le résultat est stocké dans y  

C'est encore assez léger, avec un temps d'exécution de seulement 37uS pour ce même PIC18.

Si elle n'a pas besoin d'être cryptographique forte:

• choisissez une clé aléatoire de même longueur en bits;
• partager la clé entre l'expéditeur et le destinataire;
• expéditeur -side: crypto-text = clé EOR en texte clair (vous pouvez faire cet octet par octet ).

Facultatif:

• receiver -side clear-text = crypto-text EOR key.