Skip to content
This repository
Browse code

Merge pull request #53 from revington/v0.6.18-release-crypto

V0.6.18 release crypto
  • Loading branch information...
commit 91038b9feaadcc4e1608e781bcb8b72482dd4252 2 parents a8eb2da + ffb7342
Damián Suárez authored

Showing 1 changed file with 98 additions and 94 deletions. Show diff stats Hide diff stats

  1. 192  doc/api/crypto.markdown
192  doc/api/crypto.markdown
Source Rendered
@@ -15,15 +15,14 @@ Además ofrece un conjunto de envoltorios para los métodos hash, hmac, cipher,
15 15
 Crea un objeto credenciales, con los detalles opcionales en forma de diccionario con las siguientes claves:
16 16
 
17 17
 * `key` : cadena que contiene la clave privada codificada en PEM.
18  
-* `passphrase` : A string of passphrase for the private key
  18
+* `passphrase` : cadena que contiene la passphrase de la clave privada.
19 19
 * `cert` : cadena que contiene el certificado codificado en PEM.
20 20
 * `ca` : cadena o lista de cadenas de certificados de confianza codificados en PEM.
21  
-* `crl` : Either a string or list of strings of PEM encoded CRLs (Certificate Revocation List)
22  
-* `ciphers`: A string describing the ciphers to use or exclude. Consult
23  
-  <http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT> for details
24  
-  on the format.
  21
+* `crl` : una cadena o lista de cadenas de CRL (lista de revocación de certificados) codificados en formato PEM.
  22
+* `ciphers`: una cadena que especifica los algoritmos de cifrado que deben usarse o excluirse. Consulte
  23
+<http://www.openssl.org/docs/apps/ciphers.html#CIPHER_LIST_FORMAT> para detalles relativos al formato
25 24
 
26  
-Si no se han dado ningún elemento en `ca`, node.js usará la lista de CAs de confianza publicadas como dice en
  25
+Si no se ha dado ningún elemento en `ca`, node.js usará la lista de CAs de confianza publicadas como dice en
27 26
 <http://mxr.mozilla.org/mozilla/source/security/nss/lib/ckfw/builtins/certdata.txt>.
28 27
 
29 28
 
@@ -36,7 +35,7 @@ dado que puede ser usado para generar el hash digests.
36 35
 Algunos ejemplos son `'sha1'`, `'md5'`, `'sha256'`, `'sha512'`, etc. 
37 36
 En versiones recientes, `openssl list-message-digest-algorithms` mostrará los algoritmos digest disponibles.
38 37
 
39  
-Example: this program that takes the sha1 sum of a file
  38
+Ejemplo: este programa calcula la suma sha1 de un fichero
40 39
 
41 40
     var filename = process.argv[2];
42 41
     var crypto = require('crypto');
@@ -56,24 +55,24 @@ Example: this program that takes the sha1 sum of a file
56 55
 
57 56
 ## Class: Hash
58 57
 
59  
-The class for creating hash digests of data.
  58
+Clase para calcular sumas hash de datos
60 59
 
61  
-Returned by `crypto.createHash`.
  60
+Devuelto  por `crypto.createHash`.
62 61
 
63 62
 ### hash.update(data)
64 63
 
65  
-Actualiza el contenido del hash con el `data` dado. the encoding of which is given
66  
-in `input_encoding` and can be `'utf8'`, `'ascii'` or `'binary'`.
67  
-Defaults to `'binary'`.
  64
+Actualiza el contenido del hash con el `data` dado. La codificación de este viene dada en
  65
+ `input_encoding` y puede ser `'utf8'`, `'ascii'` o `'binary'`.
  66
+Por defecto es `'binary'`.
68 67
 Esto puede ser invocado muchas veces con dato nuevo mientras estos van llegando.
69 68
 
70 69
 ### hash.digest([encoding])
71 70
 
72 71
 Calcula el digest todos los datos que van al hash.
73 72
 La codificación (`encoding`) puede ser `'hex'`, `'binary'` o `'base64'`.
74  
-Por omisíón es `'binary'`.
  73
+Por omisión es `'binary'`.
75 74
 
76  
-Note: `hash` object can not be used after `digest()` method been called.
  75
+Nota: el objeto `hash` no puede ser usado después de haber invocado `digest()`.
77 76
 
78 77
 
79 78
 ### crypto.createHmac(algorithm, key)
@@ -85,9 +84,9 @@ Crea y devuelve un objeto hmac, un hmac criptográfico con el algoritmo y la cla
85 84
 
86 85
 ## Class: Hmac
87 86
 
88  
-Class for creating cryptographic hmac content.
  87
+Clase para crear contenidos autenticados mediante hmac.
89 88
 
90  
-Returned by `crypto.createHmac`.
  89
+Devuelto por `crypto.createHmac`.
91 90
 
92 91
 ### hmac.update(data)
93 92
 
@@ -100,7 +99,7 @@ Calcula el digest (resumen) de todos los datos que van al hmac.
100 99
 La codificación (`encoding`) puede ser `'hex'`, `'binary'` o `'base64'`.
101 100
 Por omisíón es `'binary'`.
102 101
 
103  
-Note: `hmac` object can not be used after `digest()` method been called.
  102
+Nota: El objeto `hmac` no puede ser usado tras la llamada a `digest()`.
104 103
 
105 104
 
106 105
 ### crypto.createCipher(algorithm, key)
@@ -110,22 +109,22 @@ Crea y devuelve un objeto cipher (codificador), con el algoritmo y la clave dada
110 109
 `algorithm` es dependiente de OpenSSL, por ejemplo `'aes192'`, etc.
111 110
 En versiones recientes, `openssl list-cipher-algorithms` mostrará 
112 111
 los algoritmos cipher disponibles.
113  
-`password` is used to derive key and IV, which must be `'binary'` encoded
114  
-string (See the [Buffer section](buffer.html) for more information).
  112
+`password` se usa para derivar la clave y el IV (vector de inicialización), debe ser una cadena de texto codificada en  `'binary'` 
  113
+(consulta [Buffer section](buffer.html) para más información).
115 114
 
116 115
 ## crypto.createCipheriv(algorithm, key, iv)
117 116
 
118  
-Creates and returns a cipher object, with the given algorithm, key and iv.
  117
+Crea y obtiene un objeto de cifrado configurado con el algoritmo dado, clave e IV.
119 118
 
120  
-`algorithm` is the same as the `createCipher()`. `key` is a raw key used in
121  
-algorithm. `iv` is an Initialization vector. `key` and `iv` must be `'binary'`
122  
-encoded string (See the [Buffer section](buffer.html) for more information).
  119
+`algorithm` es el mismo que `createCipher()`. `key` es la clave usada por 
  120
+el algoritmo. `iv` es el vector de inicialización. `key` e `iv` deben ser cadenas de texto codificadas como `'binary'`
  121
+(Consulta [Buffer section](buffer.html) para más información).
123 122
 
124 123
 ## Class: Cipher
125 124
 
126  
-Class for encrypting data.
  125
+Clase para encriptar datos.
127 126
 
128  
-Returned by `crypto.createCipher` and `crypto.createCipheriv`.
  127
+Devuelto por `crypto.createCipher` y `crypto.createCipheriv`.
129 128
 
130 129
 ### cipher.update(data, [input_encoding], [output_encoding])
131 130
 
@@ -143,13 +142,13 @@ Devuelve el contenido codificado, y puede ser llamado muchas veces a medida que
143 142
 Devuelve cualquier contenido codificado restante, donde `output_encoding` puede ser:
144 143
 `'binary'`, `'base64'` o `'hex'`. Por omisión `'binary'`.
145 144
 
146  
-Note: `cipher` object can not be used after `final()` method been called.
  145
+Nota: El objeto `cipher` no puede ser usado tras la llamada a `final()`.
147 146
 
148 147
 ### cipher.setAutoPadding(auto_padding=true)
149 148
 
150  
-You can disable automatic padding of the input data to block size. If `auto_padding` is false,
151  
-the length of the entire input data must be a multiple of the cipher's block size or `final` will fail.
152  
-Useful for non-standard padding, e.g. using `0x0` instead of PKCS padding. You must call this before `cipher.final`.
  149
+Puede deshabilitar el relleno (padding) automático. Si `auto_padding` se establece en false,
  150
+el tamaño de los datos a cifrar debe ser múltiplo del tamaño del bloque de cifrado. De lo contrario `final` fallará.
  151
+Es útil si desea utilizar un relleno no estándar, p.e. `0x0` en vez de PKCS. Debe invocarlo antes que a `cipher.final`.
153 152
 
154 153
 
155 154
 ### crypto.createDecipher(algorithm, key)
@@ -164,17 +163,17 @@ El `output_decoding` especifica en qué formato devolver el texto plano decodifi
164 163
 
165 164
 ## Class: Decipher
166 165
 
167  
-Class for decrypting data.
  166
+Clase para decodificar datos
168 167
 
169  
-Returned by `crypto.createDecipher` and `crypto.createDecipheriv`.
  168
+Devuelto por `crypto.createDecipher` y `crypto.createDecipheriv`.
170 169
 
171 170
 ### decipher.update(data, [input_encoding], [output_encoding])
172 171
 
173  
-Updates the decipher with `data`, which is encoded in `'binary'`, `'base64'`
174  
-or `'hex'`. Defaults to `'binary'`.
  172
+Actualiza el descifrador con los datos (`'data'`) suministrados, que
  173
+habrán sido codificados en `'binary'`, `'base64'` o `'hex'`. Por defecto `'binary'`.
175 174
 
176  
-The `output_decoding` specifies in what format to return the deciphered
177  
-plaintext: `'binary'`, `'ascii'` or `'utf8'`. Defaults to `'binary'`.
  175
+`output_decoding` especifica en que codificación debe retornarse el texto descifrado. 
  176
+Esta puede ser: `'binary'`, `'ascii'` o `'utf8'`. Por defecto `'binary'`.
178 177
 
179 178
 ### decipher.final([output_encoding])
180 179
 
@@ -182,25 +181,26 @@ Devuelve el texto plano decodificado restante, siendo
182 181
 `output_encoding` `'binary'`, `'ascii'` o `'utf8'`.
183 182
 Por omisión `'binary'`.
184 183
 
185  
-Note: `decipher` object can not be used after `final()` method been called.
  184
+Nota: El objeto `decipher` no podrá ser usado tras la llamada a `final()`.
186 185
 
187 186
 ### decipher.setAutoPadding(auto_padding=true)
188 187
 
189  
-You can disable auto padding if the data has been encrypted without standard block padding to prevent
190  
-`decipher.final` from checking and removing it. Can only work if the input data's length is a multiple of the
191  
-ciphers block size. You must call this before streaming data to `decipher.update`.
  188
+Puede desactivar el relleno automático si los datos fueron cifrados sin un relleno de bloque estándar.
  189
+Con esto previene que `decipher.final` chequee y elimine el relleno. 
  190
+Solo puede funcionar si el tamaño de los datos es múltiplo del tamaño del bloque de cifrado.
  191
+Debe invocar esta función antes de enviar datos a `decipher.update`.
192 192
 
193 193
 ## crypto.createSign(algorithm)
194 194
 
195 195
 Crea y devuelve un objeto firma (signing) con el algoritmo dado.
196 196
 En versiones recientes, `openssl list-public-key-algorithms` muestra
197  
-los algoritmos de firmado disponibles. Por ejemplo: `'RSA-SHA256
  197
+los algoritmos de firmado disponibles. Por ejemplo: `'RSA-SHA256'`
198 198
 
199 199
 ## Class: Signer
200 200
 
201  
-Class for generating signatures.
  201
+Clase para generar firmas.
202 202
 
203  
-Returned by `crypto.createSign`.
  203
+Devuelto por `crypto.createSign`.
204 204
 
205 205
 ### signer.update(data)
206 206
 
@@ -209,13 +209,13 @@ Puede ser llamado muchas veces a medida que nuevos datos van llegando.
209 209
 
210 210
 ### signer.sign(private_key, output_format='binary')
211 211
 
212  
-Calcula la firma en todos los datos actualizados pasados a través del objetvo firma.
  212
+Calcula la firma en todos los datos actualizados pasados a través del objeto firma.
213 213
 `private_key` es una cadena que contiene la clave privada para firmar codificada en PEM.
214 214
 
215 215
 Devuelve la firma en `output_format` que puede estar en `'binary'`, `'hex'` o 
216 216
 `'base64'`. Por omisión `'binary'`.
217 217
 
218  
-Note: `signer` object can not be used after `sign()` method been called.
  218
+Nota: El objeto `signer` no puede usarse tras la llamada a `sign()`.
219 219
 
220 220
 ### crypto.createVerify(algorithm)
221 221
 
@@ -239,87 +239,91 @@ Verifica los datos firmados usando `cert`, que es una cadena que contiene la lla
239 239
 
240 240
 Devuelve true o false dependiendo en la validez de la firma para el dato y la clave pública dadas.
241 241
 
242  
-Note: `verifier` object can not be used after `verify()` method been called.
  242
+Nota: El objeto `verifier` no debe usarse tras la llamada a `verify()`.
243 243
 
244 244
 ## crypto.createDiffieHellman(prime_length)
245 245
 
246  
-Creates a Diffie-Hellman key exchange object and generates a prime of the
247  
-given bit length. The generator used is `2`.
  246
+Crea un objeto para el intercambio de claves mediante el protocolo criptográfico Diffie-Hellman 
  247
+y genera un número primo con la longitud de bits indicada en `prime_length`.
  248
+El generador usado es `2`.
248 249
 
249 250
 ## crypto.createDiffieHellman(prime, [encoding])
250 251
 
251  
-Creates a Diffie-Hellman key exchange object using the supplied prime. The
252  
-generator used is `2`. Encoding can be `'binary'`, `'hex'`, or `'base64'`.
253  
-Defaults to `'binary'`.
  252
+Crea un objeto para el intercambio de claves mediante el protocolo criptográfico Diffie-Hellman 
  253
+usando el número primo suministrado.
  254
+El generador usado es `2`.
  255
+La codificación puede ser `'binary'`, `'hex'`, o `'base64'`.
  256
+Por defecto `'binary'`.
254 257
 
255 258
 ## Class: DiffieHellman
256 259
 
257  
-The class for creating Diffie-Hellman key exchanges.
  260
+Clase para crear intercambios de clave mediante el protocolo criptográfico Diffie-Hellman
258 261
 
259  
-Returned by `crypto.createDiffieHellman`.
  262
+Devuelto por `crypto.createDiffieHellman`.
260 263
 
261 264
 ### diffieHellman.generateKeys([encoding])
262 265
 
263  
-Generates private and public Diffie-Hellman key values, and returns the
264  
-public key in the specified encoding. This key should be transferred to the
265  
-other party. Encoding can be `'binary'`, `'hex'`, or `'base64'`.
266  
-Defaults to `'binary'`.
  266
+Genera claves Diffie-Hellman, pública y privada, y devuelve la clave pública con la codificación especificada.
  267
+Esta clave debe ser transferida a la otra parte —la otra persona, máquina, etc.
  268
+La codificación puede ser `'binary'`, `'hex'`, o `'base64'`.
  269
+Por defecto `'binary'`.
267 270
 
268 271
 ### diffieHellman.computeSecret(other_public_key, [input_encoding], [output_encoding])
269 272
 
270  
-Computes the shared secret using `other_public_key` as the other party's
271  
-public key and returns the computed shared secret. Supplied key is
272  
-interpreted using specified `input_encoding`, and secret is encoded using
273  
-specified `output_encoding`. Encodings can be `'binary'`, `'hex'`, or
274  
-`'base64'`. The input encoding defaults to `'binary'`.
275  
-If no output encoding is given, the input encoding is used as output encoding.
  273
+Computa el secreto compartido sirviéndose de la clave pública (`other_public_key`) del emisor del mensaje 
  274
+y devuelve el valor ya computado del secreto compartido.
  275
+La clave suministrada es interpretada usando la codificación especificada en `input_encoding`.
  276
+Para el secreto se usa la especificada en `output_encoding`.
  277
+
  278
+Las codificaciones admitidas son: `'binary'`, `'hex'`, o `'base64'`.
  279
+La codificación por omisión para `input_encoding` es `'binary'`.
  280
+Si no se especifica una codificación para `output_encoding` se usará la misma que para `input_encoding`.
276 281
 
277 282
 ### diffieHellman.getPrime([encoding])
278 283
 
279  
-Returns the Diffie-Hellman prime in the specified encoding, which can be
280  
-`'binary'`, `'hex'`, or `'base64'`. Defaults to `'binary'`.
  284
+Devuelve el primo Diffie-Hellman en la codificación especificada que puede ser
  285
+`'binary'`, `'hex'`, o `'base64'`. Por defecto `'binary'`.
281 286
 
282 287
 ### diffieHellman.getGenerator([encoding])
283 288
 
284  
-Returns the Diffie-Hellman prime in the specified encoding, which can be
285  
-`'binary'`, `'hex'`, or `'base64'`. Defaults to `'binary'`.
  289
+Devuelve el primo Diffie-Hellman en la codificación especificada que puede ser
  290
+`'binary'`, `'hex'`, o `'base64'`. Por defecto `'binary'`.
286 291
 
287 292
 ### diffieHellman.getPublicKey([encoding])
288 293
 
289  
-Returns the Diffie-Hellman public key in the specified encoding, which can
290  
-be `'binary'`, `'hex'`, or `'base64'`. Defaults to `'binary'`.
  294
+Devuelve la clave pública Diffie-Hellman en la codificación especificada que puede ser
  295
+`'binary'`, `'hex'`, o `'base64'`. Por defecto `'binary'`.
291 296
 
292 297
 ### diffieHellman.getPrivateKey([encoding])
293 298
 
294  
-Returns the Diffie-Hellman private key in the specified encoding, which can
295  
-be `'binary'`, `'hex'`, or `'base64'`. Defaults to `'binary'`.
  299
+Devuelve la clave privada Diffie-Hellman en la codificación especificada que puede ser
  300
+`'binary'`, `'hex'`, o `'base64'`. Por defecto `'binary'`.
296 301
 
297 302
 ### diffieHellman.setPublicKey(public_key, [encoding])
298 303
 
299  
-Sets the Diffie-Hellman public key. Key encoding can be `'binary'`, `'hex'`,
300  
-or `'base64'`. Defaults to `'binary'`.
  304
+Establece la clave pública Diffie-Hellman en la codificación especificada que puede ser
  305
+`'binary'`, `'hex'`, o `'base64'`. Por defecto `'binary'`.
301 306
 
302 307
 ### diffieHellman.setPrivateKey(public_key, [encoding])
303 308
 
304  
-Sets the Diffie-Hellman private key. Key encoding can be `'binary'`, `'hex'`,
305  
-or `'base64'`. Defaults to `'binary'`.
  309
+Establece la clave privada Diffie-Hellman en la codificación especificada que puede ser
  310
+`'binary'`, `'hex'`, o `'base64'`. Por defecto `'binary'`.
306 311
 
307 312
 ## crypto.getDiffieHellman(group_name)
  313
+Crea un objeto predefinido Diffie-Hellman para el intercambio de claves.
  314
+Los grupos soportados son: `'modp1'`, `'modp2'`, `'modp5'`
  315
+(definidos en el [RFC 2412](http://www.rfc-editor.org/rfc/rfc2412.txt ))
  316
+y `'modp14'`, `'modp15'`, `'modp16'`, `'modp17'`, `'modp18'`
  317
+(definidos en el [RFC 3526](http://www.rfc-editor.org/rfc/rfc3526.txt )).
  318
+El objeto devuelto tiene la misma interfaz que los objetos creados mediante
  319
+
  320
+[crypto.createDiffieHellman()](#crypto.createDiffieHellman), pero no permitirá
  321
+el cambio de claves (mediante
  322
+[diffieHellman.setPublicKey()](#diffieHellman.setPublicKey) por ejemplo).
  323
+La ventaja de usar esta rutina radica en que las partes no tienen que generar ni 
  324
+intercambiar el grupo de antemano, ahorrándose ambos tanto tiempo de proceso como de comunicación.
308 325
 
309  
-Creates a predefined Diffie-Hellman key exchange object.
310  
-The supported groups are: `'modp1'`, `'modp2'`, `'modp5'`
311  
-(defined in [RFC 2412](http://www.rfc-editor.org/rfc/rfc2412.txt ))
312  
-and `'modp14'`, `'modp15'`, `'modp16'`, `'modp17'`, `'modp18'`
313  
-(defined in [RFC 3526](http://www.rfc-editor.org/rfc/rfc3526.txt )).
314  
-The returned object mimics the interface of objects created by
315  
-[crypto.createDiffieHellman()](#crypto.createDiffieHellman) above, but
316  
-will not allow to change the keys (with
317  
-[diffieHellman.setPublicKey()](#diffieHellman.setPublicKey) for example).
318  
-The advantage of using this routine is that the parties don't have to
319  
-generate nor exchange group modulus beforehand, saving both processor and
320  
-communication time.
321  
-
322  
-Example (obtaining a shared secret):
  326
+Ejemplo (obteniendo un secreto compartido):
323 327
 
324 328
     var crypto = require('crypto');
325 329
     var alice = crypto.getDiffieHellman('modp5');
@@ -331,18 +335,18 @@ Example (obtaining a shared secret):
331 335
     var alice_secret = alice.computeSecret(bob.getPublicKey(), 'binary', 'hex');
332 336
     var bob_secret = bob.computeSecret(alice.getPublicKey(), 'binary', 'hex');
333 337
 
334  
-    /* alice_secret and bob_secret should be the same */
  338
+    /* alice_secret y bob_secret deben ser iguales */
335 339
     console.log(alice_secret == bob_secret);
336 340
 
337 341
 ## crypto.pbkdf2(password, salt, iterations, keylen, callback)
338 342
 
339  
-Asynchronous PBKDF2 applies pseudorandom function HMAC-SHA1 to derive
340  
-a key of given length from the given password, salt and iterations.
341  
-The callback gets two arguments `(err, derivedKey)`.
  343
+El (asíncrono) PBKDF2 aplica una función pseudoaleatoria HMAC-SHA1 para derivar una clave, con 
  344
+la longitud dada para el `password` suministrado, valor salt e iteraciones.
  345
+El callback recibe dos argumentos `(err, derivedKey)`.
342 346
 
343 347
 ## crypto.randomBytes(size, [callback])
344 348
 
345  
-Generates cryptographically strong pseudo-random data. Usage:
  349
+Genera números pseudoaleatorios. Criptográficamente fuerte. Uso:
346 350
 
347 351
     // async
348 352
     crypto.randomBytes(256, function(ex, buf) {
@@ -356,4 +360,4 @@ Generates cryptographically strong pseudo-random data. Usage:
356 360
       console.log('Have %d bytes of random data: %s', buf.length, buf);
357 361
     } catch (ex) {
358 362
       // handle error
359  
-    }
  363
+    }

0 notes on commit 91038b9

Please sign in to comment.
Something went wrong with that request. Please try again.