Plus de détail sur Uint32Array et crypto

Version imprimable

26/03/2016, 01h38
ascito

Plus de détail sur Uint32Array et crypto
salut à tous,

je me replonge un peu dans les fondamentaux (node , nwjs) javascript.

en vue de générer une clé aléatoire, sur une de mes recherches, je suis tombé sur cette méthode :
Code:

1 2 3 4 5 6 7 8 var array = new Uint32Array(10); window.crypto.getRandomValues(array); console.log("Your lucky numbers:"); for (var i = 0; i < array.length; i++) { console.log(array[i]); }
https://developer.mozilla.org/fr/doc...etRandomValues

tout cela étant dit, j'ai du mal à voir le rapport avec https://developer.mozilla.org/fr/doc...ux/Uint32Array, et comment ça fonctionne grosso-modo.

alors, est-ce encore une bonne pratique, que représente exactement ce Uint32array?

merci de nous prêter vos lanternes sur ce coup la!
26/03/2016, 13h26
01001111

Personnellement, j'utilise cryptoJS pour générer des clés aléatoires côté client, de type privée/publique, mais ça dépend de l'utilisation que tu veux en faire.
un UInt32Array, c'est un pile d'entiers non signés dont tu ne contrôles pas le boutisme, c'est à dire l'ordre des bits (petit boutien=little endian=les bits de poids faible en premier).
Ils sont initialisés à 0 et la méthode que tu veux appeler ici génère à la place du zéro un nombre aléatoire de 32 bits soit 4 octets
Quant à te dire comment fonctionne la génération des nombres aléatoires par cette méthode, je ne le peux pas actuellement.
J'espère avoir fait un peu avancer le schmilblick.

plus sur la librairie crypto sur le site du w3c:
https://dvcs.w3.org/hg/webcrypto-api.../Overview.html
27/03/2016, 12h15
ascito

bonjour, merci pour le lien, j'en ajoute 2 qui me sembles intéressent

//liste des fonctionnalités par l'exemple
https://github.com/diafygi/webcrypto-examples

//tutos de l'api
http://qnimate.com/post-series/web-c...-api-tutorial/
27/03/2016, 17h27
autran

@Ascito

Un petit mot sur ce que tu viens de poster.

Dans ton bout de code tu viens de générer aléatoirement ta phrase clé que par abus de langage on appelle clé. Ta clé est composée de 10 caractères et chaque caractère est codé sur 32 bits.

L'objet window.crypto que tu as utilisé pour générer ta phrase clé aléatoire contient un objet subtleCrypto. Cet objet subtleCrypto contient à son tour des méthodes qui te permettront de générer les clés et de chiffrer ou déchiffrer tes messages avec les algorithmes de chiffrement choisis.

Cette API Mozilla est en réalité dans le noyau du navigateur donc valable seulement sur firefox chrome edge ou safari (pas sur Internet Explorer). Et servira pour faire du chiffrement coté client.

Je fais pour ma part couramment du chiffrement AES avec et ça marche très bien.
En espérant que cela t'éclairera un peu, car cette API est assez violente en terme de niveau de développement. En effet elle exige que le développeur connaisse les Callback et les Promises.

@autran

Salut, en effet, l'explication que tu donnes, est encore pas si simple, et l'exemple de dev.moz est assez fouillis je trouves pour se mettre un peu dans le sujet.

1 ) bien noté le non IE, à vérifier sur IE10, edge non?
> je suis en test sur NWJS, c'est donc pas un problème pour moi pour le moment, mais c'est bien de le savoir!

2 ) Clairement, c'est pas évident d'expliquer ce que représente un [0], quand il faut l'expliquer, mais on peu l'admettre!

3 ) J'avance donc un peu pour la question du crypto, fais quelques tests...

l’écriture du code donne ça pour le moment

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
(function(global) {
    'use strict';
 
    var self, object, forEach, crypto, instance, stringToArrayBufferView, arrayBufferViewToString, arrayBufferToHexaDecimal;
 
    object = Object.create.bind(null, null);
    forEach = Function.call.bind(Array.prototype.forEach);
    crypto = global.crypto || global.msCrypto || null;
 
    stringToArrayBufferView = function(str) {
        var bytes;
 
        bytes = new Uint8Array(str.length);
 
        forEach(str, function(strchar, iterator) {
            bytes[iterator] = str.charCodeAt(iterator);
        });
 
        return bytes;
    };
 
    arrayBufferViewToString = function(buffer) {
        var str = "";
 
        forEach(buffer.byteLength, function(strchar, iterator) {
            str += String.fromCharCode(strchar);
        });
 
        return str;
    };
 
    arrayBufferToHexaDecimal = function(buffer) {
        //draft message : à étudier!
        var data_view, hex, iii, c;
 
        data_view = new DataView(buffer);
        hex = '';
 
        for (iii = 0; iii < data_view.byteLength; iii += 1) {
            c = data_view.getUint8(iii).toString(16);
            if (c.length < 2) {
                c = '0' + c;
            }
 
            hex += c;
        }
 
        return hex;
    };
 
    instance = function() {
        var self;
 
        self = object();
 
        if (!crypto || !crypto.subtle) {
            //draft error && error();
        }
 
        self.hash = function(data, options, callback) {
            //draft options && callback(error);
            var promise;
 
            promise = crypto.subtle.digest({
                name: "SHA-256"
            }, stringToArrayBufferView(data));
 
            promise.then(function(result) {
                callback && callback(arrayBufferToHexaDecimal(result));
            });
        };
 
        //draft methods
        /*
        self.param
        self.hash
        self.sign
        self.syncEncrypt
        self.syncDecryt
        self.asyncEncrypt
        self.ayncDecryt
        self.generateKey
        self.keyExport
        self.keyImport
        ... 
        */
        return self;
    }
 
 
    if (typeof module === 'object' && module.exports) {
        module.exports = instance;
    }
    if (typeof define === 'function' && define.amd) {
        return define(instance);
    } else {
        //draft DOM implementation
        /*
        global[NS].crypo = instance;
        */
    }
}(this));

voilà, sujet ouvert à de la doc, des liens, des conseils etc!

Merci

28/03/2016, 10h30
01001111

Apparemment, crypto, y compris son objet crypto.subtle sont disponibles à partir de IE11
cf https://msdn.microsoft.com/fr-fr/lib...(v=vs.85).aspx

[0] est une sorte de pointeur en javascript, sur une chaine, il renvoie un caractère, sur un objet de type tableau, il renvoie l'objet contenu à l'index 0, non?