dergeorg/SmartShopper
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

https

Browse Source 
express server läuft jetzt mit https
This commit is contained in:
Lukas Nowy
2018-12-16 19:08:08 +01:00
parent 5589b0df3f
commit fd947bd852
475 changed files with 91128 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
express-server/node_modules/ursa-optional/test/.eslintrc.json generated vendored Normal file
View File

@ -0,0 +1,5 @@
{
"rules": {
"no-unused-vars": [2]
}
}

15
express-server/node_modules/ursa-optional/test/another_zorch.pem generated vendored Normal file
View File

@ -0,0 +1,15 @@
-----BEGIN RSA PRIVATE KEY-----
MIICXAIBAAKBgQDhVzXvfTvYzne0gkD9FHlTYhsuB6wBUIZRNTZaai4EpKzleZbr
hq/R7M4DMA4UbiiuI68fMagcFYgUgfspDb3QBYVSRDpF0OmxGm4ww0LOjsHH/0ZQ
LnsFvbHNQcgJiYkLHQFRi9ARweuZNCRnw3fMY1GhfO5sq7J7SzAAbKQ3vwIDAQAB
AoGAOPTnMBpyZxGA1kJaFN348KeKgS71PfvRh3Mwwte1u/y3quT5zZxkkmYNiGa8
GFPjumhQmkzd1gNnOu/DwRO1Fwbp0bfqwCLnd2Lz400ZrwN/S+hlzu+YR1rKOH7C
7q/BeAm/hGVejsmkl16WgEpkqTzo11566Gat9UWDAw7C1ZkCQQD2MkPuQH6P5hwF
sy0mr4zfA3+X0L032jyjajakgM9Zn2XnPeYL/R/Cx0h1oBke3CPrKNaRhRCrBwUz
MUx3gkm7AkEA6lBXfCfsiPWzLe6klV+vFaDl40x53AMy+pL0VE/f8GSqHwGPL1q1
aa2AtiSCD505g6vq934V3K/KDK2THug3zQJAHnGIxOVkwRaLUIkfhDEhElK0bGl7
fHSYGvz/VMg427RCPZ4B3Gmoi8VoyGLLuG0wY9vg7I2vyfZMRlBKTFzoEQJAIeh2
gJUWect0npUGZEdwguTB397VU61y1yglC35zncozhEEpg2TRE/XzxmgKGlBaXl+m
pSIt773Qs3z66WIZkQJBAN4pwewrHawHa9yLH5X9zomL8yk7kboRguk2BaZND+KP
ENbnMowAligtYJ7w2KqpHZMJHwIOg8Yd2T9bPZKMW78=
-----END RSA PRIVATE KEY-----

30
express-server/node_modules/ursa-optional/test/blort-pass.pem generated vendored Normal file
View File

@ -0,0 +1,30 @@
-----BEGIN RSA PRIVATE KEY-----
Proc-Type: 4,ENCRYPTED
DEK-Info: DES-EDE3-CBC,0EE0329ADBEED6A1
CdxXjx5dnHDVa4swmD2X/Q9jsvN8Xcy8rUW7pcn7ijdn4uEpzVax9YD2Ewy9RsuS
3Qmhon6YdkjzqjShSXa4p2HXziZlZmgqxOHwUn1IxBK/Bne4WgpBWhkVmccCUaYm
rQhx7SwiqghzXXWvs/lDFjV9LdMFT1McUF7YY2jMmLgZjIsGKX0B/wBMF3E0/Zdo
9rYwelwS+ZYrQFcXxhZI8lg/KMmhgqEgRwjp+9z0j5H3e82Rs7eH68f2SFKld1ZY
3kQzHtTU8pGwdhWTSgxHmNMBWk2UV+TXhl88yZfYd0ugPZGk1luXu++MQLCktgfS
9xVpCmZyuxJgY8Trvf/Sc5fSfF/oB7/5TluTH5ap4jn1mELYnc/bPwZ79IKROlUs
LqcZYTRX46NLhNgqQlFyHCqOomxncxkdnkKE5jJ9AFheda4ZUX6ZL9KpCl4J13NG
aEr/D/8e/c7J5GZRWXu6kskWfDHDT/85Shpk32jxxN1/uugc3ENERojWLVoKggT8
gtbOQ2hc3g5EqFkOcofrn74M4fEd5UymJVbr6rcaFoBtwMoTB38u4ILmmdEqYPhk
1YnJUSy9etN/fJhpS1sye0ic8xrY6ymsQKc2kYvKjCf34zKUNeLHE15f4++DN2nK
7ECbfBsIZcCJ/EyS+RfO2iaPlgx/J3I3IiQRlZv6zN72ZW8xDeEZUMDzTr8LO/GG
inIWEeXiq3H6Fi7lg1QkZqG5wfsMFWiaBkm5JDCtA7RyAecwaUvetXhMhycBWIrp
/BlyYV1pmGREWzJbN2DHVO8eZJKKEWqp2tCPko3U35+t6ps6OZbiuq4xL9mOaRmx
ukn8kjl1TgoQ1NBCjXEs0q01tlzMf2GoK/KQwqZmIpEJXo0eadyLok7nK11EuDGx
AQmHP8ycXJRC34rbN8HBVE2iMiSkhZGLvXpeEo7wrSM/AflkSWwAT61unpKC26EH
eClranXixvOF8c1peAIjn0eagW4rVTFfZbNDAbKwSeNQY/keSHvmOtq9AHDU8NhN
uFl5o958qkKFyp/bgHw9CfHdvtXDebMfbSekspKcYXmI46sWy73r5AmxVY1Axh4C
lqNm3sKPhQZ2LsX17yM7M1QyBjgytH8/a5ecpFyrAmiAx1BL4mU5d3KAzxCO0sQM
ZVyin3hbTBHffh5kGU5OH2xjquKqHmUZLlNhWIsfYBKdqenXBsQoGPPwL1kVNNxj
uP4AB0Xk/BUIVvKsNfcCTr0iP8YtVXYW4jD0Y+OtoLHc6e4vLUW15cYJZIYfg9zf
5rwY8MaP2XTcJovNIsKoyEYxfnMmrlTIbaT0H7JE4nbWx4nnR7X6ybk7KbuS4dVJ
uNswQWQr6WJ29kvv4pvNCKAEPXyTQeIWw9bG8ETB7xuDXgzHJkXZPhs4vGOqTxpf
JkeJtR61rnoqFBEhncHMdF9c5fTSZRcYtTt6miNc6CYJs5tdQvY82XN4H/adqghI
NN/bqFAxLxA4RoXmibIybt+IEf2ejCl2xfWPs9ejnctYL+5JLFT4+IpOQDh/3rtG
fSKhaigLCt7yprOsAxxGg/OF6I6gwNgfeujApoTQIgq0X/frF2YvjP7xNLw8oNeU
-----END RSA PRIVATE KEY-----

27
express-server/node_modules/ursa-optional/test/blort.pem generated vendored Normal file
View File

@ -0,0 +1,27 @@
-----BEGIN RSA PRIVATE KEY-----
MIIEpAIBAAKCAQEArgov0KHVYlOtS15/WIO0Hpz9NIuWQiH/9VuCqjEnsMJdZR20
NsxiNCjMTjOXtl8jCGFAp8fyb5peT7Qlp4xZky6odeyFEc6Z9QInyRSVBozlRoYS
hefQ6JSPFaF9k+FYFN/xz0LYHZwZCW+r78dQV9ZGKBQT61El8NiriiqKq1SBZiEI
7jT18J0i6H1qFVAkkZcyz3v85/yudPUC1wBFwzfk9yJ9O8bpNlGonxlDoQKXxHS8
yV15dTqAAoeVysBqQk1/NiDQuEJMbrq3cfDll0scsnVec0dwIUNY9UasxrbPpwk0
0ce54uWjwYl/sQ+AOvKZhJXbJFEfKyFi8f2EdQIDAQABAoIBADZx7V9hITXvY2kO
mNwB55kkF3oWqNzrcf05sXi4g+giBcGaN0RlT9ttX+ye6zkcLgNzGRzjyg3rxtE8
VANEPslycTTi1wYpEbS6BeQ70hsIfLlBPA4z5QC9aL2llXlrp3hwTl8+VAl/Sb3P
94O9YH76A1yKW2jkK/Bad99zS4opEvKRaBdMN3epphrUaUbseCckrgQp5/JVxSLm
0/rQ7fFhGjiTbn7YdMHLzDkESqUqVdpuU7XQYupb3xiLlHMthgNRzhkrPEHOlcyy
l5WIxP5mEoBbIc1WteiwgYkPhHpGFSXkXmsnmuqpI504JXvWyOZ0CVLBpcg1+YOl
9JG9askCgYEA5sSIz8Z8AJ2uQ4sWfP44kfd2kSFPcEY8ehyRewR+qOtA1S9Jni0y
5BSYUP3a6Z8eolj70SAVY68WQ1HHVyzPv84RRKYRUiMQPccUZbTjLYtX+fGjriQc
EhchV0ZHSweCsu5S0LdZtcWIF2t4Kq+6fLD8aFjfv5KgzkP5/EhoDNsCgYEAwRHF
CrijUmzqjhielwp72frwJOdjdsb9RT5kZMOvlCyPpxjdTZwW3AXScKrzotYAFzlS
70FxIcB2ewStZwObMVk91ZWDU8QI4aMf6P/aN7hNILmbPsZ8HXEEYrWzxNFtTtfP
YqLCDMbuvSEaQ3/K+lVU3j/6OlAWVbo72fFBzO8CgYEAuIC+GdFJ53wqjhowWrMv
K5U9GQAW8V9WjxM0RbTsR8X/yfLK20qr+6tztJ2iX1M3PPoEK8mJEHA2TpCd3lcX
qvTo3YghJRifraTz6/VaBVn5dv75rQt13gjcQVkROy3AE6t0Tyeo9CoAiykDpK1n
XrZquEsGabakFwZGYqzJdC0CgYBv4zhpyi78KZqU1rexmKXF4aMh/+aogxFr+4h6
zN0H5fsqP0KhI4Ar6kPWf3vKNnK/Ar2JYkeJ49vF1yQWuwRJSQqIqKj+9nCfMsXf
Zca02932xRmu+6AZ/9Em015nBWdvdan944zJks/wUyrBS2H6SVFxq2n8OUV4UQE2
gJY9iQKBgQDazbQaXKDuJDHTMsvZfIXdhXC0vbWb5P0TJ0lUz5lN5dfLxVj/MyCS
7Es98RTf+4wcBMBUDO5Qs5/2Wv0ZSkb2SCJ73Tvs7cnJZwY7MpY53wvhr4jIjAog
DdvScUn3F/qn8sURn0uu9Kz9fqrC/tZeANU6cpBBtWykTLb/spmwuQ==
-----END RSA PRIVATE KEY-----

9
express-server/node_modules/ursa-optional/test/blort.pub generated vendored Normal file
View File

@ -0,0 +1,9 @@
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArgov0KHVYlOtS15/WIO0
Hpz9NIuWQiH/9VuCqjEnsMJdZR20NsxiNCjMTjOXtl8jCGFAp8fyb5peT7Qlp4xZ
ky6odeyFEc6Z9QInyRSVBozlRoYShefQ6JSPFaF9k+FYFN/xz0LYHZwZCW+r78dQ
V9ZGKBQT61El8NiriiqKq1SBZiEI7jT18J0i6H1qFVAkkZcyz3v85/yudPUC1wBF
wzfk9yJ9O8bpNlGonxlDoQKXxHS8yV15dTqAAoeVysBqQk1/NiDQuEJMbrq3cfDl
l0scsnVec0dwIUNY9UasxrbPpwk00ce54uWjwYl/sQ+AOvKZhJXbJFEfKyFi8f2E
dQIDAQAB
-----END PUBLIC KEY-----

1
express-server/node_modules/ursa-optional/test/blort.sshpub generated vendored Normal file
View File

@ -0,0 +1 @@
ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCuCi/QodViU61LXn9Yg7QenP00i5ZCIf/1W4KqMSewwl1lHbQ2zGI0KMxOM5e2XyMIYUCnx/Jvml5PtCWnjFmTLqh17IURzpn1AifJFJUGjOVGhhKF59DolI8VoX2T4VgU3/HPQtgdnBkJb6vvx1BX1kYoFBPrUSXw2KuKKoqrVIFmIQjuNPXwnSLofWoVUCSRlzLPe/zn/K509QLXAEXDN+T3In07xuk2UaifGUOhApfEdLzJXXl1OoACh5XKwGpCTX82INC4Qkxuurdx8OWXSxyydV5zR3AhQ1j1RqzGts+nCTTRx7ni5aPBiX+xD4A68pmEldskUR8rIWLx/YR1

215
express-server/node_modules/ursa-optional/test/fixture.js generated vendored Normal file
View File

@ -0,0 +1,215 @@
// Copyright 2012 The Obvious Corporation.
/*
* Common fixture for use across tests
*/
/*
* Modules used
*/
"use strict";
var fs = require("fs");
var ursa = require("../lib/ursa");
var ursaNative = require("bindings")("ursaNative");
/*
* Variable definitions
*/
var BASE64 = "base64";
var BINARY = "binary";
var HEX = "hex";
var SHA1 = "sha1";
var SHA256 = "sha256";
var UTF8 = "utf8";
var DES_EDE3_CBC = "des-ede3-cbc";
var PASS_PRIVATE_KEY = fs.readFileSync(__dirname + "/blort-pass.pem");
var PRIVATE_KEY = fs.readFileSync(__dirname + "/blort.pem");
var PUBLIC_KEY = fs.readFileSync(__dirname + "/blort.pub");
var SSH_PUBLIC_KEY_FILE = fs.readFileSync(__dirname + "/blort.sshpub");
var PRIVATE_KEY_2 = fs.readFileSync(__dirname + "/zorch.pem");
var PUBLIC_KEY_2 = fs.readFileSync(__dirname + "/zorch.pub");
var PRIVATE_KEY_2 = fs.readFileSync(__dirname + "/zorch.pem");
var PRIVATE_KEY_3 = fs.readFileSync(__dirname + "/another_zorch.pem");
var PASSWORD = new Buffer("biscuits", UTF8);
var EXPONENT_HEX = "010001";
var MODULUS_HEX =
"ae0a2fd0a1d56253ad4b5e7f5883b41e9cfd348b964221fff55b82aa3127b0c2" +
"5d651db436cc623428cc4e3397b65f23086140a7c7f26f9a5e4fb425a78c5993" +
"2ea875ec8511ce99f50227c91495068ce546861285e7d0e8948f15a17d93e158" +
"14dff1cf42d81d9c19096fabefc75057d646281413eb5125f0d8ab8a2a8aab54" +
"81662108ee34f5f09d22e87d6a155024919732cf7bfce7fcae74f502d70045c3" +
"37e4f7227d3bc6e93651a89f1943a10297c474bcc95d79753a80028795cac06a" +
"424d7f3620d0b8424c6ebab771f0e5974b1cb2755e734770214358f546acc6b6" +
"cfa70934d1c7b9e2e5a3c1897fb10f803af2998495db24511f2b2162f1fd8475";
var PLAINTEXT = "Muffins are tasty.";
var PLAINTEXT_PADDED =
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" +
"\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "Muffins are tasty.";
var PRIVATE_CIPHERTEXT_HEX =
"98a96084dc8dfad2c4e604dc20def71acbf784b8b34ecafeb2840e238ac8031c" +
"7559004fa8337d20889b8a582af4f7d3707ab41d0a81487f0d80fb82be49537c" +
"2b9cd8dbb3b772fe0306ff9b4b99faa7cc26d5c04b1e8e79505bac1e8f2cdad2" +
"d3d8680eee3c16db8742b61935fca9679070d278f988ce4d414ab49a544c9088" +
"17a0d340a41384f4b8d826e41031ddcd3f72c29dec2fee0355a8203ea0d381a1" +
"a0f0969804d4968fb2e6220db5cf02e2c2200ff9d0a5a5037ac859a55c005ecc" +
"52ce194a6a9624c71547c96cf90d911caa4097f9cdfded71d23c9f8f5551188c" +
"8326357d54224ab25b9f29c1efdbc960a0968e4c9027cd507ffadd8dff93256c";
var PRIVATE_OLD_PAD_CIPHER_HEX =
"69d1c385929fc00f89aa98ae9cd8529afe884b581505acdcd4ceaa10bfda9adc" +
"79c472dd7e35bcc94f1146459c6a8d96e572116c7a62f1da5dd18cdb8f81e72b" +
"4a4649f40470e88c11b04fdf72e48c6adb44c41edc0c4c56074a041c03017f72" +
"f66a000066a4dbe888119c83f79e7cb8f667f0af1af41cf4adf21320fada9355" +
"6d056a2fdb1f5a9f5708e096a7408a115efa14f0e2f94feaa32322aa4af9c97a" +
"438d205f62317020e657c5057227a3d7e60a6a6658781cf41b0820988a4f9e8e" +
"b947c424248d231c3e43c711b0c4a4342a0fa484d0e3ded231a695250f4dafcf" +
"f9e94d02e3f74d4c509cfae24b8615e619805c9cdc9e85faed7d706dd6891383";
var PUBLIC_CIPHERTEXT_HEX =
"16b5e95a02db09e95bb5419998b3c5f450571578be271602828740242236e6aa" +
"0bce325d6b9a681038c864e0877a3e68e20329a3602829128385f182a20f06c7" +
"6f4c82f4f58481ff19ac2db9fd2b6b097047f741fa81a6c6a50b33259f3458b7" +
"5adcc40cc7ce71654d69936f1f77bdc684d069615ffeb71566487cdd62c55bc9" +
"5688452cb1857c91fd6cc0c7506f974ff4274a88b768f5e332b64933cabc9ef5" +
"2204e62f8682c177d5c7aa6e94e66125ad7a42eb9352e6af1ea6478e92599454" +
"65bc54fed2b45317713f7caa98cbd28a14c4c7fabe8689e735985e3fa6bd7ca8" +
"bda58bee1b3cba48cb0d1508c79c23d48413b3dc296aabf5291288783ff037ef";
var PUBLIC_CIPHERTEXT_NP_HEX =
"51b965fd83d619f9c3fec28330c7564c90439da62ec962f0c22df2e8e5bf9e52" +
"712755d4bb004a0dcfd8e6e0acc92553805c11158b3e36a3f74d4da6574514e8" +
"10313bcbe601fe43c7bb74872ab1a252ea78db775175662ed20baf05e870a265" +
"1a06afdec90e9bd7a21cba0282ae0ca07e82898bcfbcc162d4f6780f5db89216" +
"7a85bb5d26afc7551f356b054bb1ebb312fa02e212b2d0a751964a6ca790d6dd" +
"424df1beb5e7887ae8498070955ba65777b02c7e47ebbfdfc81a54b6fa506869" +
"29cf603b19cbaf1f32ad795ee8b6619b3dd8764626483425334cc892afc9e6e2" +
"ca371a850ae29336f559da16acc250600febcbd57524ccc0f181c995ce3f74ba";
var PLAINTEXT_SHA256 =
"44d7b7069244377863405b7c6a8c1e0fde6c68f02631668e41de3e9503429dcb";
var PLAINTEXT_SHA256_SIGNATURE =
"98349f92a91a2de46a897901a54b395a85fb618ac904d3d01d3c37d54fbdaba5" +
"f2f17fbcd45b9237b0b2f63398d5ab113c67cf3a356d30a14eeff9b53b0e7bef" +
"8b347d835cb60550b082d86293f5fb3354a1d6d85ff19f1c6696683dc3ff55d6" +
"72b88f3d365b0d56a65e3f974a795feee84b2097646673ccb4336950c04a3ba9" +
"bd189c9ae03ee824bd5a70a5c40c6ea0b124f4256a18a054d175e339c0f4fdfd" +
"32edacdec17940343889b2f940edf10c9da338db59972735049eea77632ff895" +
"53d42ded904959718c9cf5e43a50a315ab860be64d0bd4ef69bd01154d2108a9" +
"5127b0de26318d8b0c87eace03502c0cbfbe4683c5da7cf30bce3a386534b302";
var SSH_PUBLIC_KEY =
new Buffer(SSH_PUBLIC_KEY_FILE.toString(UTF8).slice(8), BASE64);
var SSH_PUBLIC_KEY_FINGERPRINT_HEX = "e7738e886aaf6f0301d62d459a892dc3";
var FAKE_SHA256_TO_SIGN =
"0123456789abcdef00112233445566778899aabbccddeeff9876543210fedcba";
var FAKE_SHA256_SIGNATURE =
"023fad1e5a94d417fc81ef477cc307578451791a87458794f993b9c8acd680aa" +
"0458532349fafec4df9351f6962b656b6c71fe977ec9d9c4cc2956a0d22ab9c8" +
"3a3639148d0bfe2a1d606868bee0b5a0c0d7b2bfaf80d4ed35d31f22733812dd" +
"454e8beb119c935f250000f44eeefd61d45bffb3aa42bcb8be6eb5331dc83a14" +
"bfc4df1dd2120f1d1b8539bd28cd4ebb6f3cf9439279278f5d472b75bff73c1b" +
"9b7cf713f311e3e25d7b0bfa0ee25f25f78c06335d8440e6a96318d0246c1581" +
"31c351b661694cfd688cd12f16db60ca496ca75338830d98dd1545ca835832d0" +
"15398a8dbc55eccb5c95fc9e825960ebd99b9b614e18fe0284a2def94cfe9aba";
var PRIVATE_KEY_COMPONENTS = {
modulus: new Buffer('4Vc173072M53tIJA/RR5U2IbLgesAVCGUTU2WmouBKSs5XmW64av0ezOAzAOFG4oriOvHzGoHBWIFIH7KQ290AWFUkQ6RdDpsRpuMMNCzo7Bx/9GUC57Bb2xzUHICYmJCx0BUYvQEcHrmTQkZ8N3zGNRoXzubKuye0swAGykN78=', 'base64'),
exponent: new Buffer('AQAB', 'base64'),
p: new Buffer('9jJD7kB+j+YcBbMtJq+M3wN/l9C9N9o8o2o2pIDPWZ9l5z3mC/0fwsdIdaAZHtwj6yjWkYUQqwcFMzFMd4JJuw==', 'base64'),
q: new Buffer('6lBXfCfsiPWzLe6klV+vFaDl40x53AMy+pL0VE/f8GSqHwGPL1q1aa2AtiSCD505g6vq934V3K/KDK2THug3zQ==', 'base64'),
dp: new Buffer('HnGIxOVkwRaLUIkfhDEhElK0bGl7fHSYGvz/VMg427RCPZ4B3Gmoi8VoyGLLuG0wY9vg7I2vyfZMRlBKTFzoEQ==', 'base64'),
dq: new Buffer('Ieh2gJUWect0npUGZEdwguTB397VU61y1yglC35zncozhEEpg2TRE/XzxmgKGlBaXl+mpSIt773Qs3z66WIZkQ==', 'base64'),
inverseQ: new Buffer('3inB7CsdrAdr3Isflf3OiYvzKTuRuhGC6TYFpk0P4o8Q1ucyjACWKC1gnvDYqqkdkwkfAg6Dxh3ZP1s9koxbvw==', 'base64'),
d: new Buffer('OPTnMBpyZxGA1kJaFN348KeKgS71PfvRh3Mwwte1u/y3quT5zZxkkmYNiGa8GFPjumhQmkzd1gNnOu/DwRO1Fwbp0bfqwCLnd2Lz400ZrwN/S+hlzu+YR1rKOH7C7q/BeAm/hGVejsmkl16WgEpkqTzo11566Gat9UWDAw7C1Zk=', 'base64'),
};
// From ftp://ftp.rsasecurity.com/pub/pkcs/pkcs-1/pkcs-1v2-1-vec.zip
var PSS_MODULUS_HEX =
"a2ba40ee07e3b2bd2f02ce227f36a195024486e49c19cb41bbbdfbba98b22b0e"+
"577c2eeaffa20d883a76e65e394c69d4b3c05a1e8fadda27edb2a42bc000fe88"+
"8b9b32c22d15add0cd76b3e7936e19955b220dd17d4ea904b1ec102b2e4de775"+
"1222aa99151024c7cb41cc5ea21d00eeb41f7c800834d2c6e06bce3bce7ea9a5";
var PSS_M_HEX =
"859eef2fd78aca00308bdc471193bf55bf9d78db8f8a672b484634f3c9c26e64"+
"78ae10260fe0dd8c082e53a5293af2173cd50c6d5d354febf78b26021c25c027"+
"12e78cd4694c9f469777e451e7f8e9e04cd3739c6bbfedae487fb55644e9ca74"+
"ff77a53cb729802f6ed4a5ffa8ba159890fc";
var PSS_MHASH_HEX =
"37b66ae0445843353d47ecb0b4fd14c110e62d6a";
var PSS_EM_HEX =
"66e4672e836ad121ba244bed6576b867d9a447c28a6e66a5b87dee7fbc7e65af" +
"5057f86fae8984d9ba7f969ad6fe02a4d75f7445fefdd85b6d3a477c28d24ba1" +
"e3756f792dd1dce8ca94440ecb5279ecd3183a311fc896da1cb39311af37ea4a" +
"75e24bdbfd5c1da0de7cecdf1a896f9d8bc816d97cd7a2c43bad546fbe8cfebc";
var PSS_S_HEX =
"8daa627d3de7595d63056c7ec659e54406f10610128baae821c8b2a0f3936d54" +
"dc3bdce46689f6b7951bb18e840542769718d5715d210d85efbb596192032c42" +
"be4c29972c856275eb6d5a45f05f51876fc6743deddd28caec9bb30ea99e02c3" +
"488269604fe497f74ccd7c7fca1671897123cbd30def5d54a2b5536ad90a747e";
var PSS_PUBLIC_KEY = fs.readFileSync(__dirname + "/pss_tv.pub");
/*
* Exported bindings
*/
module.exports = {
BASE64: BASE64,
BINARY: BINARY,
HEX: HEX,
SHA1: SHA1,
SHA256: SHA256,
UTF8: UTF8,
DES_EDE3_CBC: DES_EDE3_CBC,
EXPONENT_HEX: EXPONENT_HEX,
FAKE_SHA256_TO_SIGN: FAKE_SHA256_TO_SIGN,
FAKE_SHA256_SIGNATURE: FAKE_SHA256_SIGNATURE,
MODULUS_HEX: MODULUS_HEX,
PASSWORD: PASSWORD,
PASS_PRIVATE_KEY: PASS_PRIVATE_KEY,
PLAINTEXT: PLAINTEXT,
PLAINTEXT_PADDED: PLAINTEXT_PADDED,
PLAINTEXT_SHA256: PLAINTEXT_SHA256,
PLAINTEXT_SHA256_SIGNATURE: PLAINTEXT_SHA256_SIGNATURE,
PRIVATE_CIPHERTEXT_HEX: PRIVATE_CIPHERTEXT_HEX,
PRIVATE_OLD_PAD_CIPHER_HEX: PRIVATE_OLD_PAD_CIPHER_HEX,
PRIVATE_KEY: PRIVATE_KEY,
PRIVATE_KEY_2: PRIVATE_KEY_2,
PRIVATE_KEY_3: PRIVATE_KEY_3,
PUBLIC_CIPHERTEXT_HEX: PUBLIC_CIPHERTEXT_HEX,
PUBLIC_CIPHERTEXT_NP_HEX: PUBLIC_CIPHERTEXT_NP_HEX,
PUBLIC_KEY: PUBLIC_KEY,
PUBLIC_KEY_2: PUBLIC_KEY_2,
SSH_PUBLIC_KEY: SSH_PUBLIC_KEY,
SSH_PUBLIC_KEY_FINGERPRINT_HEX: SSH_PUBLIC_KEY_FINGERPRINT_HEX,
PRIVATE_KEY_COMPONENTS: PRIVATE_KEY_COMPONENTS,
PSS_MODULUS_HEX: PSS_MODULUS_HEX,
PSS_M_HEX: PSS_M_HEX,
PSS_MHASH_HEX: PSS_MHASH_HEX,
PSS_EM_HEX: PSS_EM_HEX,
PSS_S_HEX: PSS_S_HEX,
PSS_PUBLIC_KEY: PSS_PUBLIC_KEY,
RsaWrap: ursaNative.RsaWrap,
ursa: ursa,
ursaNative: ursaNative
};

752
express-server/node_modules/ursa-optional/test/native.js generated vendored Normal file
View File

@ -0,0 +1,752 @@
// Copyright 2012 The Obvious Corporation.
/*
* Tests of the underlying RsaWrap class.
*/
/*
* Modules used
*/
"use strict";
var assert = require("assert");
var fixture = require("./fixture");
var RsaWrap = fixture.RsaWrap;
var ursaNative = fixture.ursaNative;
var textToNid = ursaNative.textToNid;
var nodeVersion = Number(process.version.match(/^v(\d+\.\d+)/)[1]);
/**
* Asserts that two strings are equal, ignoring Windows newline differences
*/
function assertStringEqual(actual, expected, message) {
assert.equal(actual.replace(/\r\n/g, '\n'), expected.replace(/\r\n/g, '\n'), message);
}
describe('native', function() {
it('new', function() {
new RsaWrap();
});
it('setPrivateKeyPem', function() {
var rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PASS_PRIVATE_KEY, fixture.PASSWORD);
});
it('fail_setPrivateKeyPem', function() {
var rsa = new RsaWrap();
function f1() {
rsa.setPrivateKeyPem();
}
assert.throws(f1, /Missing args\[0]\./);
function f2() {
rsa.setPrivateKeyPem("x");
}
assert.throws(f2, /Expected a Buffer in args\[0]\./);
function f3() {
rsa.setPrivateKeyPem(new Buffer("x"));
}
assert.throws(f3, /no start line/);
function f4() {
rsa.setPrivateKeyPem(fixture.PASS_PRIVATE_KEY, undefined);
}
assert.throws(f4, /Expected a Buffer in args\[1]\./);
function f5() {
rsa.setPrivateKeyPem(fixture.PASS_PRIVATE_KEY, "x");
}
assert.throws(f5, /Expected a Buffer in args\[1]\./);
function f6() {
rsa.setPrivateKeyPem(fixture.PASS_PRIVATE_KEY,
new Buffer("INCORRECT PASS"));
}
assert.throws(f6, /bad decrypt/);
// Check for "set once."
function f7() {
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
}
f7();
assert.throws(f7, /Key already set\./);
});
it('setPublicKeyPem', function() {
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
});
it('fail_setPublicKeyPem', function() {
var rsa = new RsaWrap();
function f1() {
rsa.setPublicKeyPem();
}
assert.throws(f1, /Missing args\[0]\./);
function f2() {
rsa.setPublicKeyPem("x");
}
assert.throws(f2, /Expected a Buffer in args\[0]\./);
function f3() {
rsa.setPublicKeyPem(new Buffer("x"));
}
assert.throws(f3, /no start line/);
// Check for "set once."
function f4() {
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
}
f4();
assert.throws(f4, /Key already set\./);
});
it('getExponent', function() {
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var value = rsa.getExponent().toString(fixture.HEX);
assert.equal(value, fixture.EXPONENT_HEX);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
value = rsa.getExponent().toString(fixture.HEX);
assert.equal(value, fixture.EXPONENT_HEX);
});
it('fail_getExponent', function() {
var rsa = new RsaWrap();
function f1() {
rsa.getExponent();
}
assert.throws(f1, /Key not yet set\./);
});
it('getModulus', function() {
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var value = rsa.getModulus().toString(fixture.HEX);
assert.equal(value, fixture.MODULUS_HEX);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
value = rsa.getModulus().toString(fixture.HEX);
assert.equal(value, fixture.MODULUS_HEX);
});
it('fail_getModulus', function() {
var rsa = new RsaWrap();
function f1() {
rsa.getModulus();
}
assert.throws(f1, /Key not yet set\./);
});
it('getPrivateExponent', function() {
var rsa = new RsaWrap();
rsa.createPrivateKeyFromComponents(
fixture.PRIVATE_KEY_COMPONENTS.modulus,
fixture.PRIVATE_KEY_COMPONENTS.exponent,
fixture.PRIVATE_KEY_COMPONENTS.p,
fixture.PRIVATE_KEY_COMPONENTS.q,
fixture.PRIVATE_KEY_COMPONENTS.dp,
fixture.PRIVATE_KEY_COMPONENTS.dq,
fixture.PRIVATE_KEY_COMPONENTS.inverseQ,
fixture.PRIVATE_KEY_COMPONENTS.d);
var value = rsa.getPrivateExponent();
assert.equal(value.toString(fixture.HEX), fixture.PRIVATE_KEY_COMPONENTS.d.toString(fixture.HEX));
});
it('getPrivateKeyPem', function() {
var keyStr = fixture.PRIVATE_KEY.toString(fixture.UTF8);
var rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
var pem = rsa.getPrivateKeyPem().toString(fixture.UTF8);
assertStringEqual(pem, keyStr);
});
it.skip('getPrivateKeyPemWithPassPhrase', function() {
var keyStr = fixture.PASS_PRIVATE_KEY.toString(fixture.UTF8);
var rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PASS_PRIVATE_KEY, fixture.PASSWORD);
var pem = rsa.getPrivateKeyPem(fixture.PASSWORD, fixture.DES_EDE3_CBC).toString(fixture.UTF8);
assertStringEqual(pem, keyStr);
})
it('fail_getPrivateKeyPem', function() {
var rsa = new RsaWrap();
function f1() {
rsa.getPrivateKeyPem();
}
assert.throws(f1, /Key not yet set\./);
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
assert.throws(f1, /Expected a private key\./);
});
it('getPublicKeyPem', function() {
var keyStr = fixture.PUBLIC_KEY.toString(fixture.UTF8);
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var pem = rsa.getPublicKeyPem().toString(fixture.UTF8);
assertStringEqual(pem, keyStr);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
pem = rsa.getPublicKeyPem().toString(fixture.UTF8);
assertStringEqual(pem, keyStr);
});
it('fail_getPublicKeyPem', function() {
var rsa = new RsaWrap();
function f1() {
rsa.getPublicKeyPem();
}
assert.throws(f1, /Key not yet set\./);
});
it('privateDecrypt', function() {
var rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
var encoded = new Buffer(fixture.PRIVATE_CIPHERTEXT_HEX, fixture.HEX);
var decoded = rsa.privateDecrypt(encoded, ursaNative.RSA_PKCS1_OAEP_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
encoded = new Buffer(fixture.PRIVATE_OLD_PAD_CIPHER_HEX, fixture.HEX);
decoded = rsa.privateDecrypt(encoded, ursaNative.RSA_PKCS1_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
});
it('fail_privateDecrypt', function() {
var rsa = new RsaWrap();
function f1() {
rsa.privateDecrypt();
}
assert.throws(f1, /Key not yet set\./);
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
assert.throws(f1, /Expected a private key\./);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
function f2() {
rsa.privateDecrypt("x", ursaNative.RSA_PKCS1_OAEP_PADDING);
}
assert.throws(f2, /Expected a Buffer in args\[0]\./);
function f3() {
rsa.privateDecrypt(new Buffer("x"), ursaNative.RSA_PKCS1_OAEP_PADDING);
}
assert.throws(f3, /decoding error/);
function f4() {
rsa.privateDecrypt(new Buffer("x"), "str");
}
assert.throws(f4, /Expected a 32-bit integer/);
});
it('publicEncrypt', function() {
// No other reasonable way to test this than to do a round trip.
var plainBuf = new Buffer(fixture.PLAINTEXT, fixture.UTF8);
var priv = new RsaWrap();
priv.setPrivateKeyPem(fixture.PRIVATE_KEY);
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var encoded = rsa.publicEncrypt(plainBuf, ursaNative.RSA_PKCS1_OAEP_PADDING);
var decoded = priv.privateDecrypt(encoded, ursaNative.RSA_PKCS1_OAEP_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
encoded = priv.publicEncrypt(plainBuf, ursaNative.RSA_PKCS1_OAEP_PADDING);
decoded = priv.privateDecrypt(encoded, ursaNative.RSA_PKCS1_OAEP_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
// Test with old-style padding.
encoded = rsa.publicEncrypt(plainBuf, ursaNative.RSA_PKCS1_PADDING);
decoded = priv.privateDecrypt(encoded, ursaNative.RSA_PKCS1_PADDING);
decoded = decoded.toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
});
it('fail_publicEncrypt', function() {
var rsa = new RsaWrap();
function f1() {
rsa.publicEncrypt();
}
assert.throws(f1, /Key not yet set\./);
rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
function f2() {
rsa.publicEncrypt("x", ursaNative.RSA_PKCS1_OAEP_PADDING);
}
assert.throws(f2, /Expected a Buffer in args\[0]\./);
function f3() {
rsa.publicEncrypt(new Buffer(2048), ursaNative.RSA_PKCS1_OAEP_PADDING);
}
assert.throws(f3, /too large/);
function f4() {
rsa.publicEncrypt(new Buffer("x"), "str");
}
assert.throws(f4, /Expected a 32-bit integer/);
});
it('privateEncrypt', function() {
var rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
var plainBuf = new Buffer(fixture.PLAINTEXT, fixture.UTF8);
var encoded = rsa.privateEncrypt(plainBuf, ursaNative.RSA_PKCS1_PADDING).toString(fixture.HEX);
assert.equal(encoded, fixture.PUBLIC_CIPHERTEXT_HEX);
});
it('fail_privateEncrypt', function() {
var rsa = new RsaWrap();
function f1() {
rsa.privateEncrypt();
}
assert.throws(f1, /Key not yet set\./);
rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
assert.throws(f1, /Expected a private key\./);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
function f2() {
rsa.privateEncrypt("x", ursaNative.RSA_PKCS1_PADDING);
}
assert.throws(f2, /Expected a Buffer in args\[0]\./);
function f3() {
rsa.privateEncrypt(new Buffer(2048), ursaNative.RSA_PKCS1_PADDING);
}
assert.throws(f3, /too large/);
});
it('publicDecrypt', function() {
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var encoded = new Buffer(fixture.PUBLIC_CIPHERTEXT_HEX, fixture.HEX);
var decoded = rsa.publicDecrypt(encoded, ursaNative.RSA_PKCS1_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
encoded = new Buffer(fixture.PUBLIC_CIPHERTEXT_HEX, fixture.HEX);
decoded = rsa.publicDecrypt(encoded, ursaNative.RSA_PKCS1_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
});
it('fail_publicDecrypt', function() {
var rsa = new RsaWrap();
function f1() {
rsa.publicDecrypt();
}
assert.throws(f1, /Key not yet set\./);
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
function f2() {
rsa.publicDecrypt("x", ursaNative.RSA_PKCS1_PADDING);
}
assert.throws(f2, /Expected a Buffer in args\[0]\./);
function f3() {
rsa.publicDecrypt(new Buffer("x"), ursaNative.RSA_PKCS1_PADDING);
}
assert.throws(f3, /padding_check/);
});
it('generatePrivateKey', function() {
var rsa = new RsaWrap();
rsa.generatePrivateKey(512, 65537);
// Do a round trip check.
var plainBuf = new Buffer(fixture.PLAINTEXT, fixture.UTF8);
var encoded = rsa.publicEncrypt(plainBuf, ursaNative.RSA_PKCS1_OAEP_PADDING);
var decoded = rsa.privateDecrypt(encoded, ursaNative.RSA_PKCS1_OAEP_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
// Extract the public key, and try using it for a round trip.
var pubKey = new RsaWrap();
pubKey.setPublicKeyPem(rsa.getPublicKeyPem());
encoded = pubKey.publicEncrypt(plainBuf, ursaNative.RSA_PKCS1_OAEP_PADDING);
decoded = rsa.privateDecrypt(encoded, ursaNative.RSA_PKCS1_OAEP_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
// Similarly, try decoding with an extracted private key.
var privKey = new RsaWrap();
privKey.setPrivateKeyPem(rsa.getPrivateKeyPem());
decoded = privKey.privateDecrypt(encoded, ursaNative.RSA_PKCS1_OAEP_PADDING).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
});
it('fail_generatePrivateKey', function() {
var rsa = new RsaWrap();
function f1() {
rsa.generatePrivateKey();
}
assert.throws(f1, /Missing args\[0]\./);
function f2() {
rsa.generatePrivateKey("x");
}
assert.throws(f2, /Expected a 32-bit integer in args\[0]\./);
function f3() {
rsa.generatePrivateKey(10);
}
assert.throws(f3, /Missing args\[1]\./);
function f4() {
rsa.generatePrivateKey(20, "x");
}
assert.throws(f4, /Expected a 32-bit integer in args\[1]\./);
function f5() {
rsa.generatePrivateKey(512, 2);
}
assert.throws(f5, /Expected odd exponent\./);
function f6() {
rsa.generatePrivateKey(512, 0);
}
assert.throws(f6, /Expected positive exponent\./);
function f7() {
rsa.generatePrivateKey(511, 1);
}
assert.throws(f7, /Expected modulus bit count >= 512\./);
// Use the original f1(), above, for this test.
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
assert.throws(f1, /Key already set\./);
});
it('sign', function() {
var rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
var buf = new Buffer(fixture.FAKE_SHA256_TO_SIGN, fixture.HEX);
var sig = rsa.sign(textToNid(fixture.SHA256), buf);
assert.equal(sig.toString(fixture.HEX), fixture.FAKE_SHA256_SIGNATURE);
buf = new Buffer(fixture.PLAINTEXT_SHA256, fixture.HEX);
sig = rsa.sign(textToNid(fixture.SHA256), buf);
assert.equal(sig.toString(fixture.HEX), fixture.PLAINTEXT_SHA256_SIGNATURE);
});
it('fail_sign', function() {
var rsa = new RsaWrap();
function f1() {
rsa.sign();
}
assert.throws(f1, /Key not yet set\./);
rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
assert.throws(f1, /Expected a private key\./);
rsa = new RsaWrap();
rsa.setPrivateKeyPem(fixture.PRIVATE_KEY);
function f2() {
rsa.sign("x", "x");
}
assert.throws(f2, /Expected a 32-bit integer in args\[0]\./);
function f3() {
rsa.sign(1, "x");
}
assert.throws(f3, /Expected a Buffer in args\[1]\./);
function f4() {
rsa.sign(1, new Buffer(2048));
}
assert.throws(f4, /too big/);
function f5() {
rsa.sign(99999, new Buffer(16));
}
assert.throws(f5, /unknown algorithm/);
});
it('verify', function() {
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var hash = new Buffer(fixture.FAKE_SHA256_TO_SIGN, fixture.HEX);
var sig = new Buffer(fixture.FAKE_SHA256_SIGNATURE, fixture.HEX);
assert.equal(rsa.verify(textToNid(fixture.SHA256), hash, sig), true);
// Private keys should be able to verify too.
hash = new Buffer(fixture.PLAINTEXT_SHA256, fixture.HEX);
sig = new Buffer(fixture.PLAINTEXT_SHA256_SIGNATURE, fixture.HEX);
assert.equal(rsa.verify(textToNid(fixture.SHA256), hash, sig), true);
// Signature mismatch should return false (and not, e.g., throw).
hash = new Buffer(fixture.FAKE_SHA256_TO_SIGN, fixture.HEX);
sig = new Buffer(fixture.PLAINTEXT_SHA256_SIGNATURE, fixture.HEX);
assert.equal(rsa.verify(textToNid(fixture.SHA256), hash, sig), false);
});
it('fail_verify', function() {
var rsa = new RsaWrap();
function f1() {
rsa.verify();
}
assert.throws(f1, /Key not yet set\./);
rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
function f2() {
rsa.verify("x", "x", "x");
}
assert.throws(f2, /Expected a 32-bit integer in args\[0]\./);
function f3() {
rsa.verify(1, "x", "x");
}
assert.throws(f3, /Expected a Buffer in args\[1]\./);
function f4() {
rsa.verify(1, new Buffer(16), "x");
}
assert.throws(f4, /Expected a Buffer in args\[2]\./);
function f5() {
var hash = new Buffer(10);
var sig = new Buffer(5);
hash.fill(0);
sig.fill(0);
rsa.verify(1, hash, sig);
}
assert.throws(f5, /wrong signature length/);
function f6() {
var buf = new Buffer(256);
buf.fill(0);
rsa.verify(1, new Buffer(10), buf);
}
assert.throws(f6, /padding_check/);
function f7() {
var hash = new Buffer(fixture.PLAINTEXT_SHA256, fixture.HEX);
var sig = new Buffer(fixture.PLAINTEXT_SHA256_SIGNATURE, fixture.HEX);
rsa.verify(textToNid(fixture.SHA1), hash, sig);
}
if (nodeVersion < 10) {
assert.throws(f7, /algorithm mismatch/);
} else {
assert.ifError(f7(), true);
}
function f8() {
var hash = new Buffer(fixture.PLAINTEXT_SHA256, fixture.HEX);
var sig = new Buffer(fixture.PLAINTEXT_SHA256_SIGNATURE, fixture.HEX);
rsa.verify(1234567, hash, sig);
}
assert.throws(f8, nodeVersion < 10 ? /algorithm mismatch/ : /unknown algorithm type/);
});
it('textToNid', function() {
// I don't think you can count on the return values being anything
// other than integer values and that aliases should return equal
// values.
function verifyInt(value) {
if (typeof value !== "number") {
throw new Exception("Not a number: " + value);
}
if (value !== Math.floor(value)) {
throw new Exception("Not an integer: " + value);
}
}
verifyInt(textToNid("aes-128-ecb"));
verifyInt(textToNid("md5"));
verifyInt(textToNid("rsa"));
verifyInt(textToNid("sha1"));
verifyInt(textToNid("sha256"));
verifyInt(textToNid("RSA-SHA256"));
verifyInt(textToNid("pkcs7"));
assert.equal(textToNid("RSA-SHA256"), textToNid("sha256WithRSAEncryption"));
assert.equal(textToNid("AES-128-ECB"), textToNid("aes-128-ecb"));
});
it('fail_textToNid', function() {
function f1() {
textToNid();
}
assert.throws(f1, /Missing args\[0\]/);
function f2() {
textToNid(123);
}
assert.throws(f2, /Expected a string in args\[0\]/);
function f3() {
textToNid("blort");
}
assert.throws(f3, /asn1/);
});
it('PSSPadding', function() {
_test_PSSPadding(ursaNative.RSA_PKCS1_SALT_LEN_HLEN);
_test_PSSPadding(ursaNative.RSA_PKCS1_SALT_LEN_RECOVER);
var rsa = new RsaWrap();
rsa.createPublicKeyFromComponents(
new Buffer(fixture.PSS_MODULUS_HEX, fixture.HEX),
new Buffer(fixture.EXPONENT_HEX, fixture.HEX));
var tvhash = new Buffer(fixture.PSS_MHASH_HEX, fixture.HEX);
var tvem = new Buffer(fixture.PSS_EM_HEX, fixture.HEX);
assert.equal(rsa.verifyPSSPadding(
textToNid(fixture.SHA1), tvhash, tvem, ursaNative.RSA_PKCS1_SALT_LEN_HLEN), true);
});
it('fail_PSSPadding', function() {
var rsa = new RsaWrap();
function f1() {
rsa.addPSSPadding();
}
assert.throws(f1, /Key not yet set\./);
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
assert.throws(f1, /Not enough args\./);
var nid = textToNid(fixture.SHA256);
var hash = new Buffer(fixture.FAKE_SHA256_TO_SIGN, fixture.HEX);
var slen = ursaNative.RSA_PKCS1_SALT_LEN_HLEN;
function f2() {
rsa.addPSSPadding("x", hash, slen);
}
assert.throws(f2, /Expected a 32-bit integer in args\[0\]\./);
function f3() {
rsa.addPSSPadding(nid, "x", slen);
}
assert.throws(f3, /Expected a Buffer in args\[1\]\./);
function f4() {
rsa.addPSSPadding(nid, hash, "x");
}
assert.throws(f4, /Expected a 32-bit integer in args\[2\]\./);
function f5() {
rsa.addPSSPadding(nid, hash, 1000000);
}
assert.throws(f5, /data too large for key size/);
function f6() {
rsa.addPSSPadding(nid, hash, -3);
}
assert.throws(f6, /salt length check failed/);
var em = rsa.addPSSPadding(nid, hash, slen);
function f7() {
rsa.verifyPSSPadding();
}
assert.throws(f7, /Not enough args\./);
function f8() {
rsa.verifyPSSPadding("x", hash, em, slen);
}
assert.throws(f8, /Expected a 32-bit integer in args\[0\]\./);
function f9() {
rsa.verifyPSSPadding(nid, "x", em, slen);
}
assert.throws(f9, /Expected a Buffer in args\[1\]\./);
function f10() {
rsa.verifyPSSPadding(nid, hash, "x", slen);
}
assert.throws(f10, /Expected a Buffer in args\[2\]\./);
function f11() {
rsa.verifyPSSPadding(nid, hash, em, "x");
}
assert.throws(f11, /Expected a 32-bit integer in args\[3\]\./);
function f12() {
rsa.verifyPSSPadding(nid, hash, em, 1000000);
}
assert.throws(f12, /data too large/);
function f13() {
rsa.verifyPSSPadding(nid, hash, em, -3);
}
assert.throws(f13, /salt length check failed/);
em[em.length-1] ^= 2;
function f14() {
rsa.verifyPSSPadding(nid, hash, em, slen);
}
assert.throws(f14, /last octet invalid/);
em[em.length-1] ^= 2;
em[1] ^= 2;
assert.throws(f14, /salt length recovery failed/);
});
})
function _test_PSSPadding(slen)
{
var rsa = new RsaWrap();
rsa.setPublicKeyPem(fixture.PUBLIC_KEY);
var nid = textToNid(fixture.SHA256);
var hash = new Buffer(fixture.FAKE_SHA256_TO_SIGN, fixture.HEX);
var em = rsa.addPSSPadding(nid, hash, slen);
assert.equal(rsa.verifyPSSPadding(nid, hash, em, slen), true);
}

6
express-server/node_modules/ursa-optional/test/pss_tv.pub generated vendored Normal file
View File

@ -0,0 +1,6 @@
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCiukDuB+OyvS8CziJ/NqGVAkSG
5JwZy0G7vfu6mLIrDld8Lur/og2IOnbmXjlMadSzwFoej63aJ+2ypCvAAP6Ii5sy
wi0VrdDNdrPnk24ZlVsiDdF9TqkEsewQKy5N53USIqqZFRAkx8tBzF6iHQDutB98
gAg00sbga847zn6ppQIDAQAB
-----END PUBLIC KEY-----

608
express-server/node_modules/ursa-optional/test/test.js generated vendored Normal file
View File

@ -0,0 +1,608 @@
// Copyright 2012 The Obvious Corporation.
/*
* Tests of ursa
*/
/*
* Modules used
*/
"use strict";
var assert = require("assert");
var fixture = require("./fixture");
var ursa = fixture.ursa;
/**
* Asserts that two strings are equal, ignoring Windows newline differences
*/
function assertStringEqual(actual, expected, message) {
assert.equal(actual.replace(/\r\n/g, '\n'), expected.replace(/\r\n/g, '\n'), message);
}
/*
* Helper functions
*/
function test_getExponent(key) {
var buf = key.getExponent();
assert.equal(buf.toString(fixture.HEX), fixture.EXPONENT_HEX);
var result = key.getExponent(fixture.HEX);
assert.equal(result, fixture.EXPONENT_HEX);
result = key.getExponent(fixture.BASE64);
assert.equal(result, buf.toString(fixture.BASE64));
result = key.getExponent(fixture.BINARY);
assert.equal(result, buf.toString(fixture.BINARY));
result = key.getExponent(fixture.UTF8);
assert.equal(result, buf.toString(fixture.UTF8));
}
function test_getModulus(key) {
var buf = key.getModulus();
assert.equal(buf.toString(fixture.HEX), fixture.MODULUS_HEX);
var result = key.getModulus(fixture.HEX);
assert.equal(result, fixture.MODULUS_HEX);
result = key.getModulus(fixture.BASE64);
assert.equal(result, buf.toString(fixture.BASE64));
result = key.getModulus(fixture.BINARY);
assert.equal(result, buf.toString(fixture.BINARY));
result = key.getModulus(fixture.UTF8);
assert.equal(result, buf.toString(fixture.UTF8));
}
function test_toPublicPem(key) {
var keyString = fixture.PUBLIC_KEY.toString(fixture.UTF8);
var result = key.toPublicPem().toString(fixture.UTF8);
assertStringEqual(result, keyString);
result = key.toPublicPem(fixture.UTF8);
assertStringEqual(result, keyString);
}
function test_toPublicSsh(key) {
var keyString = fixture.SSH_PUBLIC_KEY.toString(fixture.BASE64);
var result = key.toPublicSsh().toString(fixture.BASE64);
assert.equal(result, keyString);
result = key.toPublicSsh(fixture.BASE64);
assert.equal(result, keyString);
}
function test_toPublicSshFingerprint(key) {
var result = key.toPublicSshFingerprint().toString(fixture.HEX);
assert.equal(result, fixture.SSH_PUBLIC_KEY_FINGERPRINT_HEX);
result = key.toPublicSshFingerprint(fixture.HEX);
assert.equal(result, fixture.SSH_PUBLIC_KEY_FINGERPRINT_HEX);
}
function test_encrypt(key) {
// The sanest way to test this is to do a round trip.
var privKey = ursa.createPrivateKey(fixture.PRIVATE_KEY)
var encoded = key.encrypt(new Buffer(fixture.PLAINTEXT, fixture.UTF8));
var decoded = privKey.decrypt(encoded, undefined, fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
encoded = key.encrypt(fixture.PLAINTEXT, fixture.UTF8, fixture.BASE64);
decoded = privKey.decrypt(encoded, fixture.BASE64, fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
encoded = key.encrypt(fixture.PLAINTEXT, undefined, fixture.HEX);
decoded = privKey.decrypt(encoded, fixture.HEX, fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
}
function test_publicDecrypt(key) {
var encoded = new Buffer(fixture.PUBLIC_CIPHERTEXT_HEX, fixture.HEX);
var decoded = key.publicDecrypt(encoded).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
decoded = key.publicDecrypt(fixture.PUBLIC_CIPHERTEXT_HEX, fixture.HEX,
fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
decoded = key.publicDecrypt(fixture.PUBLIC_CIPHERTEXT_NP_HEX, fixture.HEX,
fixture.UTF8, ursa.RSA_NO_PADDING);
assert.equal(decoded, fixture.PLAINTEXT_PADDED);
}
function test_verify(key) {
assert.equal(key.verify(fixture.SHA256, fixture.PLAINTEXT_SHA256,
fixture.PLAINTEXT_SHA256_SIGNATURE,
fixture.HEX), true);
var hash = new Buffer(fixture.PLAINTEXT_SHA256, fixture.HEX);
var sig = new Buffer(fixture.PLAINTEXT_SHA256_SIGNATURE, fixture.HEX);
assert.equal(key.verify(fixture.SHA256, hash, sig), true);
}
function test_hashAndVerify(key) {
assert.equal(key.hashAndVerify(fixture.SHA256,
new Buffer(fixture.PLAINTEXT, fixture.UTF8),
fixture.PLAINTEXT_SHA256_SIGNATURE,
fixture.HEX),
true);
var key2 = ursa.createPublicKeyFromComponents(
new Buffer(fixture.PSS_MODULUS_HEX, fixture.HEX),
new Buffer(fixture.EXPONENT_HEX, fixture.HEX));
assert.equal(key2.hashAndVerify(fixture.SHA1,
fixture.PSS_M_HEX,
fixture.PSS_S_HEX,
fixture.HEX,
true,
ursa.RSA_PKCS1_SALT_LEN_HLEN),
true);
assert.equal(key2.hashAndVerify(fixture.SHA1,
fixture.PSS_M_HEX,
fixture.PSS_S_HEX,
fixture.HEX,
true),
true);
}
function testPublicKeyMethods(key) {
test_getExponent(key);
test_getModulus(key);
test_toPublicPem(key);
test_toPublicSsh(key);
test_toPublicSshFingerprint(key);
test_encrypt(key);
test_publicDecrypt(key);
test_verify(key);
test_hashAndVerify(key);
}
function test_toPrivatePem(key) {
var keyString = fixture.PRIVATE_KEY.toString(fixture.UTF8);
var result = key.toPrivatePem().toString(fixture.UTF8);
assertStringEqual(result, keyString);
result = key.toPrivatePem(fixture.UTF8);
assertStringEqual(result, keyString);
}
function test_toEncryptedPrivatePem(key) {
var password = fixture.PASSWORD.toString(fixture.UTF8);
var cipher = fixture.DES_EDE3_CBC;
var keyString = fixture.PASS_PRIVATE_KEY.toString(fixture.UTF8);
var pem = key.toEncryptedPrivatePem(password, cipher).toString(fixture.UTF8);
var plainTextKey = ursa.createPrivateKey(pem, password);
assertStringEqual(plainTextKey.toPrivatePem().toString(), fixture.PRIVATE_KEY.toString());
pem = key.toEncryptedPrivatePem(password, cipher, fixture.UTF8).toString(fixture.UTF8);
plainTextKey = ursa.createPrivateKey(pem, password);
assertStringEqual(plainTextKey.toPrivatePem().toString(), fixture.PRIVATE_KEY.toString());
}
function test_decrypt(key) {
var encoded = new Buffer(fixture.PRIVATE_CIPHERTEXT_HEX, fixture.HEX);
var decoded = key.decrypt(encoded).toString(fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
decoded = key.decrypt(fixture.PRIVATE_CIPHERTEXT_HEX, fixture.HEX,
fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
}
function test_privateEncrypt(key) {
var encoded = key.privateEncrypt(
new Buffer(fixture.PLAINTEXT, fixture.UTF8)).toString(fixture.HEX);
assert.equal(encoded, fixture.PUBLIC_CIPHERTEXT_HEX);
encoded = key.privateEncrypt(fixture.PLAINTEXT, fixture.UTF8, fixture.HEX);
assert.equal(encoded, fixture.PUBLIC_CIPHERTEXT_HEX);
encoded = key.privateEncrypt(fixture.PLAINTEXT, undefined, fixture.HEX);
assert.equal(encoded, fixture.PUBLIC_CIPHERTEXT_HEX);
encoded = key.privateEncrypt(fixture.PLAINTEXT_PADDED, fixture.UTF8, fixture.HEX, ursa.RSA_NO_PADDING);
assert.equal(encoded, fixture.PUBLIC_CIPHERTEXT_NP_HEX);
}
function test_sign(key) {
var sig = key.sign(fixture.SHA256,
fixture.PLAINTEXT_SHA256, fixture.HEX,
fixture.BASE64);
sig = new Buffer(sig, fixture.BASE64);
assert.equal(sig.toString(fixture.HEX), fixture.PLAINTEXT_SHA256_SIGNATURE);
var buf = new Buffer(fixture.PLAINTEXT_SHA256, fixture.HEX);
sig = key.sign(fixture.SHA256, buf, undefined, fixture.HEX);
assert.equal(sig, fixture.PLAINTEXT_SHA256_SIGNATURE);
}
function test_hashAndSign(key) {
var sig = key.hashAndSign(fixture.SHA256, fixture.PLAINTEXT,
fixture.UTF8, fixture.HEX);
assert.equal(sig, fixture.PLAINTEXT_SHA256_SIGNATURE);
// PSS uses random salt so can't have a fixture
var sig = key.hashAndSign(fixture.SHA256, fixture.PLAINTEXT,
fixture.UTF8, fixture.HEX,
true, ursa.RSA_PKCS1_SALT_LEN_MAX);
assert.equal(key.hashAndVerify(
fixture.SHA256,
new Buffer(fixture.PLAINTEXT).toString(fixture.HEX),
sig,
fixture.HEX,
true,
ursa.RSA_PKCS1_SALT_LEN_MAX),
true);
}
function testPrivateKeyMethods(key) {
test_toPrivatePem(key);
test_toEncryptedPrivatePem(key);
test_decrypt(key);
test_privateEncrypt(key);
test_hashAndSign(key);
test_sign(key);
}
describe('main', function() {
it('Basics', function() {
ursa.createPublicKey(fixture.PUBLIC_KEY);
ursa.createPrivateKey(fixture.PRIVATE_KEY);
ursa.createPrivateKey(fixture.PASS_PRIVATE_KEY, fixture.PASSWORD);
ursa.generatePrivateKey(512);
ursa.createPublicKey(fixture.PUBLIC_KEY.toString(fixture.UTF8));
ursa.createPrivateKey(fixture.PRIVATE_KEY.toString(fixture.BASE64),
undefined, fixture.BASE64);
});
it('Types', function() {
var pub = ursa.createPublicKey(fixture.PUBLIC_KEY);
var priv = ursa.createPrivateKey(fixture.PRIVATE_KEY);
var msg;
msg = "Problem with isKey()";
assert.equal(ursa.isKey(pub), true, msg);
assert.equal(ursa.isKey(priv), true, msg);
assert.equal(ursa.isKey(undefined), false, msg);
assert.equal(ursa.isKey("x"), false, msg);
msg = "Problem with isPublicKey()";
assert.equal(ursa.isPublicKey(pub), true, msg);
assert.equal(ursa.isPublicKey(priv), false, msg);
assert.equal(ursa.isPublicKey(undefined), false, msg);
assert.equal(ursa.isPublicKey("x"), false, msg);
msg = "Problem with isPrivateKey()";
assert.equal(ursa.isPrivateKey(pub), false, msg);
assert.equal(ursa.isPrivateKey(priv), true, msg);
assert.equal(ursa.isPrivateKey(undefined), false, msg);
assert.equal(ursa.isPrivateKey("x"), false, msg);
assert.doesNotThrow(function () { ursa.assertKey(pub); });
assert.doesNotThrow(function () { ursa.assertKey(priv); });
assert.throws(function () { ursa.assertKey(undefined); });
assert.throws(function () { ursa.assertKey("x"); });
assert.doesNotThrow(function () { ursa.assertPublicKey(pub); });
assert.throws(function () { ursa.assertPublicKey(priv); });
assert.throws(function () { ursa.assertPublicKey(undefined); });
assert.throws(function () { ursa.assertPublicKey("x"); });
assert.throws(function () { ursa.assertPrivateKey(pub); });
assert.doesNotThrow(function () { ursa.assertPrivateKey(priv); });
assert.throws(function () { ursa.assertPrivateKey(undefined); });
assert.throws(function () { ursa.assertPrivateKey("x"); });
});
it('createKey', function() {
var priv = ursa.createKey(fixture.PRIVATE_KEY);
assert(ursa.isPrivateKey(priv), true);
var pub = ursa.createKey(fixture.PUBLIC_KEY);
assert(ursa.isPublicKey(pub), true);
function f1() {
ursa.createKey("yo there");
}
assert.throws(f1, /Not a key\./);
});
it('createPrivateKeyFromComponents', function() {
var privFromComponents = ursa.createPrivateKeyFromComponents(
fixture.PRIVATE_KEY_COMPONENTS.modulus,
fixture.PRIVATE_KEY_COMPONENTS.exponent,
fixture.PRIVATE_KEY_COMPONENTS.p,
fixture.PRIVATE_KEY_COMPONENTS.q,
fixture.PRIVATE_KEY_COMPONENTS.dp,
fixture.PRIVATE_KEY_COMPONENTS.dq,
fixture.PRIVATE_KEY_COMPONENTS.inverseQ,
fixture.PRIVATE_KEY_COMPONENTS.d);
assert(ursa.isPrivateKey(privFromComponents), true);
var privFromPem = ursa.createPrivateKey(fixture.PRIVATE_KEY_3);
assert.equal(privFromComponents.toPrivatePem('utf8'), privFromPem.toPrivatePem('utf8'));
});
it('createPublicKeyFromComponents', function() {
var pubFromComponents = ursa.createPublicKeyFromComponents(
new Buffer(fixture.PSS_MODULUS_HEX, fixture.HEX),
new Buffer(fixture.EXPONENT_HEX, fixture.HEX));
assert(ursa.isPublicKey(pubFromComponents), true);
var pubFromPem = ursa.createPublicKey(fixture.PSS_PUBLIC_KEY);
assert.equal(pubFromComponents.toPublicPem('utf8'),
pubFromPem.toPublicPem('utf8'));
});
it('fail_createPublicKey', function() {
// This is mostly tested at the native level. This just tests the
// extra failures added at the high level.
function f1() {
ursa.createPublicKey(fixture.PRIVATE_KEY);
}
assert.throws(f1, /Not a public key\./);
});
it('fail_createPrivateKey', function() {
// This is mostly tested at the native level. This just tests the
// extra failures added at the high level.
function f1() {
ursa.createPrivateKey(fixture.PUBLIC_KEY);
}
assert.throws(f1, /Not a private key\./);
});
it('coerceKey', function() {
var priv = ursa.coerceKey(fixture.PRIVATE_KEY);
assert(ursa.isPrivateKey(priv), true);
priv = ursa.coerceKey(fixture.PRIVATE_KEY.toString());
assert(ursa.isPrivateKey(priv), true);
var pub = ursa.coerceKey(fixture.PUBLIC_KEY);
assert(ursa.isPublicKey(pub), true);
pub = ursa.coerceKey(fixture.PUBLIC_KEY.toString());
assert(ursa.isPublicKey(pub), true);
assert.equal(ursa.coerceKey(priv), priv);
assert.equal(ursa.coerceKey(pub), pub);
});
it('coercePrivateKey', function() {
var priv = ursa.coercePrivateKey(fixture.PRIVATE_KEY);
assert(ursa.isPrivateKey(priv), true);
priv = ursa.coercePrivateKey(fixture.PRIVATE_KEY.toString());
assert(ursa.isPrivateKey(priv), true);
assert.equal(ursa.coercePrivateKey(priv), priv);
});
it('coercePublicKey', function() {
var pub = ursa.coercePublicKey(fixture.PUBLIC_KEY);
assert(ursa.isPublicKey(pub), true);
pub = ursa.coercePublicKey(fixture.PUBLIC_KEY.toString());
assert(ursa.isPublicKey(pub), true);
assert.equal(ursa.coercePublicKey(pub), pub);
});
it('fail_coerceKey', function() {
function f1() {
ursa.coerceKey("foo");
}
assert.throws(f1, /Not a key/);
function f2() {
ursa.coerceKey(new Buffer(200));
}
assert.throws(f2, /Not a key/);
function f3() {
ursa.coerceKey([]);
}
assert.throws(f3, /Not a key/);
});
it('fail_coercePrivateKey', function() {
function f1() {
ursa.coercePrivateKey("foo");
}
assert.throws(f1, /Not a private key/);
function f2() {
ursa.coercePrivateKey(new Buffer(200));
}
assert.throws(f2, /Not a private key/);
function f3() {
ursa.coercePrivateKey([]);
}
assert.throws(f3, /Not a private key/);
function f4() {
ursa.coercePrivateKey(fixture.PUBLIC_KEY);
}
assert.throws(f4, /Not a private key/);
function f5() {
ursa.coercePrivateKey(fixture.PUBLIC_KEY.toString());
}
assert.throws(f5, /Not a private key/);
});
it('fail_coercePublicKey', function() {
function f1() {
ursa.coercePublicKey("foo");
}
assert.throws(f1, /Not a public key/);
function f2() {
ursa.coercePublicKey(new Buffer(200));
}
assert.throws(f2, /Not a public key/);
function f3() {
ursa.coercePublicKey([]);
}
assert.throws(f3, /Not a public key/);
function f4() {
ursa.coercePublicKey(fixture.PRIVATE_KEY);
}
assert.throws(f4, /Not a public key/);
function f5() {
ursa.coercePublicKey(fixture.PRIVATE_KEY.toString());
}
assert.throws(f5, /Not a public key/);
});
it('PublicKey', function() {
var key = ursa.createPublicKey(fixture.PUBLIC_KEY);
testPublicKeyMethods(key);
});
it('PrivateKey', function() {
var key = ursa.createPrivateKey(fixture.PRIVATE_KEY);
testPublicKeyMethods(key);
testPrivateKeyMethods(key);
});
it('GeneratedKey', function() {
// Just do a round trip. If that works, then it's safe to believe
// the native tests (which are more comprehensive).
var key = ursa.generatePrivateKey();
var encoded = key.encrypt(fixture.PLAINTEXT, fixture.UTF8);
var decoded = key.decrypt(encoded, undefined, fixture.UTF8);
assert.equal(decoded, fixture.PLAINTEXT);
});
it('sshFingerprint', function() {
var key = fixture.SSH_PUBLIC_KEY;
var finger = ursa.sshFingerprint(fixture.SSH_PUBLIC_KEY);
assert.equal(finger.toString(fixture.HEX),
fixture.SSH_PUBLIC_KEY_FINGERPRINT_HEX);
finger = ursa.sshFingerprint(fixture.SSH_PUBLIC_KEY, undefined,
fixture.HEX);
assert.equal(finger, fixture.SSH_PUBLIC_KEY_FINGERPRINT_HEX);
finger = ursa.sshFingerprint(
fixture.SSH_PUBLIC_KEY.toString(fixture.BASE64),
fixture.BASE64, fixture.HEX);
assert.equal(finger, fixture.SSH_PUBLIC_KEY_FINGERPRINT_HEX);
});
it('equalKeys', function() {
var pub = ursa.createPublicKey(fixture.PUBLIC_KEY);
var priv = ursa.createPrivateKey(fixture.PRIVATE_KEY);
var samePub = ursa.createPublicKey(fixture.PUBLIC_KEY);
var samePriv = ursa.createPrivateKey(fixture.PRIVATE_KEY);
var diffPub = ursa.createPublicKey(fixture.PUBLIC_KEY_2);
var diffPriv = ursa.createPrivateKey(fixture.PRIVATE_KEY_2);
assert.equal(ursa.equalKeys("1", "2"), false);
assert.equal(ursa.equalKeys(123, 123), false);
assert.equal(ursa.equalKeys(pub, null), false);
assert.equal(ursa.equalKeys(true, pub), false);
assert.equal(ursa.equalKeys(pub, pub), true);
assert.equal(ursa.equalKeys(priv, priv), true);
assert.equal(ursa.equalKeys(pub, priv), false);
assert.equal(ursa.equalKeys(priv, pub), false);
assert.equal(ursa.equalKeys(pub, samePub), true);
assert.equal(ursa.equalKeys(priv, samePriv), true);
assert.equal(ursa.equalKeys(pub, diffPub), false);
assert.equal(ursa.equalKeys(priv, diffPriv), false);
});
it('matchingPublicKeys', function() {
var pub = ursa.createPublicKey(fixture.PUBLIC_KEY);
var priv = ursa.createPrivateKey(fixture.PRIVATE_KEY);
var samePub = ursa.createPublicKey(fixture.PUBLIC_KEY);
var samePriv = ursa.createPrivateKey(fixture.PRIVATE_KEY);
var diffPub = ursa.createPublicKey(fixture.PUBLIC_KEY_2);
var diffPriv = ursa.createPrivateKey(fixture.PRIVATE_KEY_2);
assert.equal(ursa.matchingPublicKeys("1", "2"), false);
assert.equal(ursa.matchingPublicKeys(123, 123), false);
assert.equal(ursa.matchingPublicKeys(pub, null), false);
assert.equal(ursa.matchingPublicKeys(true, pub), false);
assert.equal(ursa.matchingPublicKeys(pub, pub), true);
assert.equal(ursa.matchingPublicKeys(priv, priv), true);
assert.equal(ursa.matchingPublicKeys(pub, priv), true);
assert.equal(ursa.matchingPublicKeys(priv, pub), true);
assert.equal(ursa.matchingPublicKeys(pub, samePub), true);
assert.equal(ursa.matchingPublicKeys(priv, samePriv), true);
assert.equal(ursa.matchingPublicKeys(pub, samePriv), true);
assert.equal(ursa.matchingPublicKeys(priv, samePub), true);
assert.equal(ursa.matchingPublicKeys(pub, diffPub), false);
assert.equal(ursa.matchingPublicKeys(pub, diffPriv), false);
assert.equal(ursa.matchingPublicKeys(priv, diffPriv), false);
assert.equal(ursa.matchingPublicKeys(priv, diffPub), false);
});
it('Signer', function() {
var key = ursa.createPrivateKey(fixture.PRIVATE_KEY);
var signer = ursa.createSigner(fixture.SHA256);
var ret = signer.update(fixture.PLAINTEXT, fixture.UTF8);
assert.equal(ret === signer, true);
var sig = signer.sign(key, fixture.HEX);
assert.equal(sig, fixture.PLAINTEXT_SHA256_SIGNATURE);
});
it('Verifier', function() {
var key = ursa.createPublicKey(fixture.PUBLIC_KEY);
var verifier = ursa.createVerifier(fixture.SHA256);
var ret = verifier.update(fixture.PLAINTEXT, fixture.UTF8);
assert.equal(ret === verifier, true);
assert.equal(verifier.verify(key, fixture.PLAINTEXT_SHA256_SIGNATURE,
fixture.HEX),
true);
var verifier = ursa.createVerifier(fixture.SHA256);
verifier.update(new Buffer(fixture.PLAINTEXT, fixture.UTF8));
var sigBuf = new Buffer(fixture.PLAINTEXT_SHA256_SIGNATURE, fixture.HEX);
assert.equal(verifier.verify(key, sigBuf), true);
});
it('openSshPublicKey', function() {
var sshKey = ursa.openSshPublicKey(fixture.SSH_PUBLIC_KEY),
pubKey = ursa.createPublicKey(fixture.PUBLIC_KEY);
assert.equal(ursa.equalKeys(sshKey, pubKey), true);
});
})

27
express-server/node_modules/ursa-optional/test/zorch.pem generated vendored Normal file
View File

@ -0,0 +1,27 @@
-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAtZPKWwG02rHQAZP95ckEo/rY7nAOJO+TRT5Kf7Ym4xJGBMCc
5Ach5j4o1OFzKWaHgtfGM01Le3fdGx4VwxLcSlUI9ixvlhhKEqkRpGr8vphCDx0v
g+jXseQ2axrR6uHrdYA+8ASnfiuxILDXCRLwmPlliFA4D0qoWenOmqeNT7+98opZ
eN0BQxiOE/MXluSVpdVK/IQo5ggFDMBrHmq2+5L2I7JNkZOxADcilecrSrg1bt3F
ppKWGt49tpcCldOFx50iXE7ca1y4fOtBx0rm4JPzmFIYB1hu3mIT/xd3p2MY5dMr
Q9kYbeRcxcal1xXreLyWf2KslrPwwxZFR9QVoQIDAQABAoIBAGhaJ1FmCaolxoUh
qCkG/cO/xixB+d8AUILa6bW72V1mgxb4GzJxZuoLjyvI5YZFhluL5jxVj6vFlyye
faM+k5ukgyH3J6n7C5bt01XKprZiipRlEYmdp1h071FeeIWkkM1WhtUp15iLQ6Cm
AO8WE2/W5KMSdyVSoq4J0NLQuEW705nRBw0KvKOu/16MI3ASIYAhDh2N+celiq0B
QEFdMNIY4mQwRmoW8+nTVh3szVd6GXMH0etcQlDz7dLwXYm4qSw+dQusFjYZ6s4U
HKjIxFsCy32B8XoLKi2gKY0u4SE56H9Qcp05y1fZe20lfenf3Der0ucrX0THj1/Z
HLSTJgECgYEA6qlVbK0gm/iX8p62U/t3e1NtHyv3UlmmFPuHS4Z/cX4hErym0FJk
ln/Ggo2cSlyw83TjQFPRGvCDbULa/pKJow0PyGk0+LHELk5bguGtq0EMpd2ZmUKs
QIPcWXzbzismuH3x8zcNvErCEWvU7aDW8NznZes/a4aIjUR8DdG/l6UCgYEAxha2
/EBp5YTubNIIVSROUMpzYmrJJSMdvCz7eu0yfREQFzAbgyhdOkBx7jdAzAVAINOw
iVNP2h/DcOwGgcTun7RpBQ4QToDviNKQwp2Vh/DTYpuGzYgDJzmb+UawXQhXR9/F
eWzYkb2HFZVQ6Quhd0uFE71B4NFD1FPqEDfERU0CgYBBPt/fnauJcm9dKD/tzeeE
xMd8eU8E+KQzBVSy7SyWM8miWg3PsnkBV3msZw9jpa4VoxRkmGl1ohYI1SPq0Hew
fDs9L/NoipTPgz3ygCk3ipinrZu9f0pBjehAgXTkOB9GAM67Hz2UcvzOtzq275eT
1PgJ4IT7sqZZEQelGAK7eQKBgDunK4Pbggh0d7idp5S8UjlSPl0s+1YLtTCt+y2R
sNqpAMd63U4qIakhLy4lxYWrLxyzoz43sJxnZFvlODBsNdAybE3xZke93GS/xIhX
HGjLxVy0qWvLwedWGfp/pyzdDiu+36Epfi6lfMCrLqp/rihWvcSsAeLKIjsW6i3o
HVshAoGActqcGaI+rt5A1FFwzNbZYiu8QLjtMV+Je8oryP58HZTfDf31vkIi3MdR
G4jDp9POKxkn+AIfX6GOt2skC+mJGACbjPXCcuSaIYS6LyUmdZ22N+063yiiex2M
irL6oqJcmS8k8DD34fhNPC+Z8KMkcqp0xNm9ikmJLNmEY5eeaiI=
-----END RSA PRIVATE KEY-----

9
express-server/node_modules/ursa-optional/test/zorch.pub generated vendored Normal file
View File

@ -0,0 +1,9 @@
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtZPKWwG02rHQAZP95ckE
o/rY7nAOJO+TRT5Kf7Ym4xJGBMCc5Ach5j4o1OFzKWaHgtfGM01Le3fdGx4VwxLc
SlUI9ixvlhhKEqkRpGr8vphCDx0vg+jXseQ2axrR6uHrdYA+8ASnfiuxILDXCRLw
mPlliFA4D0qoWenOmqeNT7+98opZeN0BQxiOE/MXluSVpdVK/IQo5ggFDMBrHmq2
+5L2I7JNkZOxADcilecrSrg1bt3FppKWGt49tpcCldOFx50iXE7ca1y4fOtBx0rm
4JPzmFIYB1hu3mIT/xd3p2MY5dMrQ9kYbeRcxcal1xXreLyWf2KslrPwwxZFR9QV
oQIDAQAB
-----END PUBLIC KEY-----