From 0c7e6c8e93a0e168b055f45aeca47ac85e828fb0 Mon Sep 17 00:00:00 2001 From: Jules Laplace Date: Wed, 9 Jul 2014 20:32:32 -0400 Subject: crypt(3) --- public/js/auth.js | 7 +- public/js/vendor/crypt.js | 456 ++++++++++++++++++++++++++++++++++++++++++++ public/protocols/index.html | 1 + 3 files changed, 463 insertions(+), 1 deletion(-) create mode 100644 public/js/vendor/crypt.js diff --git a/public/js/auth.js b/public/js/auth.js index e16c2d2..651e396 100644 --- a/public/js/auth.js +++ b/public/js/auth.js @@ -32,9 +32,14 @@ var Auth = return Main.saving = true warn("attempting login") + + + var password = $('#login-password').val() + password = unixCryptTD(password, password.substr(0,2)) + var data = { username: $('#login-email').val(), - password: $('#login-password').val(), + password: password, } $('#login-password').val(''), $.post(URL.auth.login, data, Auth.loginCallback) diff --git a/public/js/vendor/crypt.js b/public/js/vendor/crypt.js new file mode 100644 index 0000000..ddc97ec --- /dev/null +++ b/public/js/vendor/crypt.js @@ -0,0 +1,456 @@ +/** + * Unix crypt(3) Javascript Implementation + * + * Straightforward implementaiton of the DES-based Unix crypt(3) hash, based largely + * on crypt.c in the Seventh Edition Unix distribution released by Caldera Systems + * under a BSD-style license. + * + * @author Tim Joseph Dumol + */ + +/* +Legalese: + +Copyright(C) Tim Joseph F. Dumol 2011. All rights reserved. +Derived from crypt.c in the Seventh Edition Unix distribution by +Caldera International, which is Copyright(C) Caldera International +Inc. 2001-2002. All rights reserved. + +Redistribution and use in source and binary forms, +with or without modification, are permitted provided that the +following conditions are met: + +Redistributions of source code and documentation must retain the above +copyright notice, this list of conditions and the following +disclaimer. + +* Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +* All advertising materials mentioning features or use of this software + must display the following acknowledgement: This product includes + software developed or owned by Caldera International, Inc. + +* Neither the name of Caldera International, Inc. nor the names of + other contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA +INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE +FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR +BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN +IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ + +/** + * Implements the Unix crypt(3) DES-based hash. + * + * @param {Array.|string} pw The string to hash + * @param {Array.|string} salt The salt to use (two character string from [a-zA-Z0-9./]). + * @param {boolean=} returnBytes (optional) If true, return an array of bytes; + * otherwise, return a string. + */ +window['unixCryptTD'] = (function() { + /* + * Initial permutation, + */ + var IP = [ + 58,50,42,34,26,18,10, 2, + 60,52,44,36,28,20,12, 4, + 62,54,46,38,30,22,14, 6, + 64,56,48,40,32,24,16, 8, + 57,49,41,33,25,17, 9, 1, + 59,51,43,35,27,19,11, 3, + 61,53,45,37,29,21,13, 5, + 63,55,47,39,31,23,15, 7 + ]; + + /* + * Final permutation, FP = IP^(-1) + */ + var FP =[ + 40, 8,48,16,56,24,64,32, + 39, 7,47,15,55,23,63,31, + 38, 6,46,14,54,22,62,30, + 37, 5,45,13,53,21,61,29, + 36, 4,44,12,52,20,60,28, + 35, 3,43,11,51,19,59,27, + 34, 2,42,10,50,18,58,26, + 33, 1,41, 9,49,17,57,25 + ]; + + /* + * Permuted-choice 1 from the key bits + * to yield C and D. + * Note that bits 8,16... are left out: + * They are intended for a parity check. + */ + var PC1_C = [ + 57,49,41,33,25,17, 9, + 1,58,50,42,34,26,18, + 10, 2,59,51,43,35,27, + 19,11, 3,60,52,44,36 + ]; + + var PC1_D = [ + 63,55,47,39,31,23,15, + 7,62,54,46,38,30,22, + 14, 6,61,53,45,37,29, + 21,13, 5,28,20,12, 4 + ]; + + /* + * Sequence of shifts used for the key schedule. + */ + var shifts =[ + 1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1 + ]; + + /* + * Permuted-choice 2, to pick out the bits from + * the CD array that generate the key schedule. + */ + var PC2_C = [ + 14,17,11,24, 1, 5, + 3,28,15, 6,21,10, + 23,19,12, 4,26, 8, + 16, 7,27,20,13, 2 + ]; + + var PC2_D = [ + 41,52,31,37,47,55, + 30,40,51,45,33,48, + 44,49,39,56,34,53, + 46,42,50,36,29,32 + ]; + + /* + * The C and D arrays used to calculate the key schedule. + */ + + var C = []; + var D = []; + /* + * The key schedule. + * Generated from the key. + */ + var KS = []; + for (var i = 0; i < 16; ++i) { + KS[i] = []; + } + + /* + * Set up the key schedule from the key. + */ + + function setkey(key) { + var i, j, k, t; + + /* + * First, generate C and D by permuting + * the key. The low order bit of each + * 8-bit char is not used, so C and D are only 28 + * bits apiece. + */ + for (i=0; i<28; i++) { + C[i] = key[PC1_C[i]-1]; + D[i] = key[PC1_D[i]-1]; + } + /* + * To generate Ki, rotate C and D according + * to schedule and pick up a permutation + * using PC2. + */ + for (i=0; i<16; i++) { + /* + * rotate. + */ + for (k=0; k>3)&01; + f[t+1] = (k>>2)&01; + f[t+2] = (k>>1)&01; + f[t+3] = (k>>0)&01; + } + /* + * The new R is L ^ f(R, K). + * The f here has to be permuted first, though. + */ + for (j=0; j<32; j++) + R[j] = L[j] ^ f[P[j]-1]; + /* + * Finally, the new L (the original R) + * is copied back. + */ + for (j=0; j<32; j++) + L[j] = tempL[j]; + } + /* + * The output L and R are reversed. + */ + for (j=0; j<32; j++) { + t = L[j]; + L[j] = R[j]; + R[j] = t; + } + /* + * The final output + * gets the inverse permutation of the very original. + */ + for (j=0; j<32; ++j) { + perm[j] = L[j]; + perm[j+32] = R[j]; + } + for (j=0; j<64; j++) { + block[j] = perm[FP[j]-1]; + } + } + + /** + * Transform a string to an array of bytes + */ + var strToBytes = function(str) { + var i, x = []; + for (i = 0; i < str.length; ++i) { + x[i] = str.charCodeAt(i); + } + return x + }; + + var bytesToStr = function(bytes) { + return String.fromCharCode.apply(String, bytes); + } + + return function crypt(pw, salt, returnBytes) { + if (typeof(pw) === 'string') pw = strToBytes(pw); + if (typeof(salt) === 'string') salt = strToBytes(salt); + + var i, j, k, c, temp; + var block = [], iobuf = []; + for(i=0; i<66; i++) + block[i] = 0; + for(i=0, k=0; (c= pw[k]) && i<64; ++k){ + for(j=0; j<7; j++, i++) + block[i] = (c>>(6-j)) & 01; + i++; + } + + setkey(block); + + for(i=0; i<66; i++) + block[i] = 0; + + for(i=0;i<48;i++) + E[i] = e[i]; + + for(i=0, k=0;i<2;i++, ++k){ + c = salt[k]; + iobuf[i] = c; + if(c>'Z'.charCodeAt(0)) c -= 6; + if(c>'9'.charCodeAt(0)) c -= 7; + c -= '.'.charCodeAt(0); + for(j=0;j<6;j++){ + if((c>>j) & 01){ + temp = E[6*i+j]; + E[6*i+j] = E[6*i+j+24]; + E[6*i+j+24] = temp; + } + } + } + + for(i=0; i<25; i++) + encrypt(block,0); + + for(i=0; i<11; i++){ + c = 0; + for(j=0; j<6; j++){ + c <<= 1; + c |= block[6*i+j]; + } + c += '.'.charCodeAt(0); + if(c>'9'.charCodeAt(0)) c += 7; + if(c>'Z'.charCodeAt(0)) c += 6; + iobuf[i+2] = c; + } + if(iobuf[1]==0) + iobuf[1] = iobuf[0]; + + if (returnBytes) return(iobuf); + else return bytesToStr(iobuf); + } +})(); diff --git a/public/protocols/index.html b/public/protocols/index.html index 2c04d3f..48344f1 100644 --- a/public/protocols/index.html +++ b/public/protocols/index.html @@ -226,6 +226,7 @@ Illustration by Molly Craba + -- cgit v1.2.3-70-g09d2