parent
248b7ca5ee
commit
3af64cde3f
1328 changed files with 63706 additions and 5 deletions
@ -0,0 +1,16 @@ |
||||
#!/bin/sh |
||||
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") |
||||
|
||||
case `uname` in |
||||
*CYGWIN*|*MINGW*|*MSYS*) |
||||
if command -v cygpath > /dev/null 2>&1; then |
||||
basedir=`cygpath -w "$basedir"` |
||||
fi |
||||
;; |
||||
esac |
||||
|
||||
if [ -x "$basedir/node" ]; then |
||||
exec "$basedir/node" "$basedir/../node-gyp-build/bin.js" "$@" |
||||
else |
||||
exec node "$basedir/../node-gyp-build/bin.js" "$@" |
||||
fi |
@ -0,0 +1,16 @@ |
||||
#!/bin/sh |
||||
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") |
||||
|
||||
case `uname` in |
||||
*CYGWIN*|*MINGW*|*MSYS*) |
||||
if command -v cygpath > /dev/null 2>&1; then |
||||
basedir=`cygpath -w "$basedir"` |
||||
fi |
||||
;; |
||||
esac |
||||
|
||||
if [ -x "$basedir/node" ]; then |
||||
exec "$basedir/node" "$basedir/../node-gyp-build/optional.js" "$@" |
||||
else |
||||
exec node "$basedir/../node-gyp-build/optional.js" "$@" |
||||
fi |
@ -0,0 +1,17 @@ |
||||
@ECHO off |
||||
GOTO start |
||||
:find_dp0 |
||||
SET dp0=%~dp0 |
||||
EXIT /b |
||||
:start |
||||
SETLOCAL |
||||
CALL :find_dp0 |
||||
|
||||
IF EXIST "%dp0%\node.exe" ( |
||||
SET "_prog=%dp0%\node.exe" |
||||
) ELSE ( |
||||
SET "_prog=node" |
||||
SET PATHEXT=%PATHEXT:;.JS;=;% |
||||
) |
||||
|
||||
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\node-gyp-build\optional.js" %* |
@ -0,0 +1,28 @@ |
||||
#!/usr/bin/env pwsh |
||||
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent |
||||
|
||||
$exe="" |
||||
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { |
||||
# Fix case when both the Windows and Linux builds of Node |
||||
# are installed in the same directory |
||||
$exe=".exe" |
||||
} |
||||
$ret=0 |
||||
if (Test-Path "$basedir/node$exe") { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "$basedir/node$exe" "$basedir/../node-gyp-build/optional.js" $args |
||||
} else { |
||||
& "$basedir/node$exe" "$basedir/../node-gyp-build/optional.js" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} else { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "node$exe" "$basedir/../node-gyp-build/optional.js" $args |
||||
} else { |
||||
& "node$exe" "$basedir/../node-gyp-build/optional.js" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} |
||||
exit $ret |
@ -0,0 +1,16 @@ |
||||
#!/bin/sh |
||||
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") |
||||
|
||||
case `uname` in |
||||
*CYGWIN*|*MINGW*|*MSYS*) |
||||
if command -v cygpath > /dev/null 2>&1; then |
||||
basedir=`cygpath -w "$basedir"` |
||||
fi |
||||
;; |
||||
esac |
||||
|
||||
if [ -x "$basedir/node" ]; then |
||||
exec "$basedir/node" "$basedir/../node-gyp-build/build-test.js" "$@" |
||||
else |
||||
exec node "$basedir/../node-gyp-build/build-test.js" "$@" |
||||
fi |
@ -0,0 +1,17 @@ |
||||
@ECHO off |
||||
GOTO start |
||||
:find_dp0 |
||||
SET dp0=%~dp0 |
||||
EXIT /b |
||||
:start |
||||
SETLOCAL |
||||
CALL :find_dp0 |
||||
|
||||
IF EXIST "%dp0%\node.exe" ( |
||||
SET "_prog=%dp0%\node.exe" |
||||
) ELSE ( |
||||
SET "_prog=node" |
||||
SET PATHEXT=%PATHEXT:;.JS;=;% |
||||
) |
||||
|
||||
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\node-gyp-build\build-test.js" %* |
@ -0,0 +1,28 @@ |
||||
#!/usr/bin/env pwsh |
||||
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent |
||||
|
||||
$exe="" |
||||
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { |
||||
# Fix case when both the Windows and Linux builds of Node |
||||
# are installed in the same directory |
||||
$exe=".exe" |
||||
} |
||||
$ret=0 |
||||
if (Test-Path "$basedir/node$exe") { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "$basedir/node$exe" "$basedir/../node-gyp-build/build-test.js" $args |
||||
} else { |
||||
& "$basedir/node$exe" "$basedir/../node-gyp-build/build-test.js" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} else { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "node$exe" "$basedir/../node-gyp-build/build-test.js" $args |
||||
} else { |
||||
& "node$exe" "$basedir/../node-gyp-build/build-test.js" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} |
||||
exit $ret |
@ -0,0 +1,17 @@ |
||||
@ECHO off |
||||
GOTO start |
||||
:find_dp0 |
||||
SET dp0=%~dp0 |
||||
EXIT /b |
||||
:start |
||||
SETLOCAL |
||||
CALL :find_dp0 |
||||
|
||||
IF EXIST "%dp0%\node.exe" ( |
||||
SET "_prog=%dp0%\node.exe" |
||||
) ELSE ( |
||||
SET "_prog=node" |
||||
SET PATHEXT=%PATHEXT:;.JS;=;% |
||||
) |
||||
|
||||
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\node-gyp-build\bin.js" %* |
@ -0,0 +1,28 @@ |
||||
#!/usr/bin/env pwsh |
||||
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent |
||||
|
||||
$exe="" |
||||
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { |
||||
# Fix case when both the Windows and Linux builds of Node |
||||
# are installed in the same directory |
||||
$exe=".exe" |
||||
} |
||||
$ret=0 |
||||
if (Test-Path "$basedir/node$exe") { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "$basedir/node$exe" "$basedir/../node-gyp-build/bin.js" $args |
||||
} else { |
||||
& "$basedir/node$exe" "$basedir/../node-gyp-build/bin.js" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} else { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "node$exe" "$basedir/../node-gyp-build/bin.js" $args |
||||
} else { |
||||
& "node$exe" "$basedir/../node-gyp-build/bin.js" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} |
||||
exit $ret |
@ -0,0 +1,16 @@ |
||||
#!/bin/sh |
||||
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')") |
||||
|
||||
case `uname` in |
||||
*CYGWIN*|*MINGW*|*MSYS*) |
||||
if command -v cygpath > /dev/null 2>&1; then |
||||
basedir=`cygpath -w "$basedir"` |
||||
fi |
||||
;; |
||||
esac |
||||
|
||||
if [ -x "$basedir/node" ]; then |
||||
exec "$basedir/node" "$basedir/../uuid/dist/esm/bin/uuid" "$@" |
||||
else |
||||
exec node "$basedir/../uuid/dist/esm/bin/uuid" "$@" |
||||
fi |
@ -0,0 +1,17 @@ |
||||
@ECHO off |
||||
GOTO start |
||||
:find_dp0 |
||||
SET dp0=%~dp0 |
||||
EXIT /b |
||||
:start |
||||
SETLOCAL |
||||
CALL :find_dp0 |
||||
|
||||
IF EXIST "%dp0%\node.exe" ( |
||||
SET "_prog=%dp0%\node.exe" |
||||
) ELSE ( |
||||
SET "_prog=node" |
||||
SET PATHEXT=%PATHEXT:;.JS;=;% |
||||
) |
||||
|
||||
endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & "%_prog%" "%dp0%\..\uuid\dist\esm\bin\uuid" %* |
@ -0,0 +1,28 @@ |
||||
#!/usr/bin/env pwsh |
||||
$basedir=Split-Path $MyInvocation.MyCommand.Definition -Parent |
||||
|
||||
$exe="" |
||||
if ($PSVersionTable.PSVersion -lt "6.0" -or $IsWindows) { |
||||
# Fix case when both the Windows and Linux builds of Node |
||||
# are installed in the same directory |
||||
$exe=".exe" |
||||
} |
||||
$ret=0 |
||||
if (Test-Path "$basedir/node$exe") { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "$basedir/node$exe" "$basedir/../uuid/dist/esm/bin/uuid" $args |
||||
} else { |
||||
& "$basedir/node$exe" "$basedir/../uuid/dist/esm/bin/uuid" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} else { |
||||
# Support pipeline input |
||||
if ($MyInvocation.ExpectingInput) { |
||||
$input | & "node$exe" "$basedir/../uuid/dist/esm/bin/uuid" $args |
||||
} else { |
||||
& "node$exe" "$basedir/../uuid/dist/esm/bin/uuid" $args |
||||
} |
||||
$ret=$LASTEXITCODE |
||||
} |
||||
exit $ret |
@ -0,0 +1,67 @@ |
||||
{ |
||||
"name": "workflowTester", |
||||
"lockfileVersion": 3, |
||||
"requires": true, |
||||
"packages": { |
||||
"node_modules/bcrypt": { |
||||
"version": "6.0.0", |
||||
"resolved": "https://registry.npmjs.org/bcrypt/-/bcrypt-6.0.0.tgz", |
||||
"integrity": "sha512-cU8v/EGSrnH+HnxV2z0J7/blxH8gq7Xh2JFT6Aroax7UohdmiJJlxApMxtKfuI7z68NvvVcmR78k2LbT6efhRg==", |
||||
"hasInstallScript": true, |
||||
"license": "MIT", |
||||
"dependencies": { |
||||
"node-addon-api": "^8.3.0", |
||||
"node-gyp-build": "^4.8.4" |
||||
}, |
||||
"engines": { |
||||
"node": ">= 18" |
||||
} |
||||
}, |
||||
"node_modules/crypto": { |
||||
"version": "1.0.1", |
||||
"resolved": "https://registry.npmjs.org/crypto/-/crypto-1.0.1.tgz", |
||||
"integrity": "sha512-VxBKmeNcqQdiUQUW2Tzq0t377b54N2bMtXO/qiLa+6eRRmmC4qT3D4OnTGoT/U6O9aklQ/jTwbOtRMTTY8G0Ig==", |
||||
"deprecated": "This package is no longer supported. It's now a built-in Node module. If you've depended on crypto, you should switch to the one that's built-in.", |
||||
"license": "ISC" |
||||
}, |
||||
"node_modules/lodash": { |
||||
"version": "4.17.21", |
||||
"resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", |
||||
"integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", |
||||
"license": "MIT" |
||||
}, |
||||
"node_modules/node-addon-api": { |
||||
"version": "8.3.1", |
||||
"resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-8.3.1.tgz", |
||||
"integrity": "sha512-lytcDEdxKjGJPTLEfW4mYMigRezMlyJY8W4wxJK8zE533Jlb8L8dRuObJFWg2P+AuOIxoCgKF+2Oq4d4Zd0OUA==", |
||||
"license": "MIT", |
||||
"engines": { |
||||
"node": "^18 || ^20 || >= 21" |
||||
} |
||||
}, |
||||
"node_modules/node-gyp-build": { |
||||
"version": "4.8.4", |
||||
"resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz", |
||||
"integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==", |
||||
"license": "MIT", |
||||
"bin": { |
||||
"node-gyp-build": "bin.js", |
||||
"node-gyp-build-optional": "optional.js", |
||||
"node-gyp-build-test": "build-test.js" |
||||
} |
||||
}, |
||||
"node_modules/uuid": { |
||||
"version": "11.1.0", |
||||
"resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", |
||||
"integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", |
||||
"funding": [ |
||||
"https://github.com/sponsors/broofa", |
||||
"https://github.com/sponsors/ctavan" |
||||
], |
||||
"license": "MIT", |
||||
"bin": { |
||||
"uuid": "dist/esm/bin/uuid" |
||||
} |
||||
} |
||||
} |
||||
} |
@ -0,0 +1,6 @@ |
||||
.git/ |
||||
.vscode/ |
||||
Dockerfile* |
||||
prebuilds/ |
||||
node_modules/ |
||||
build*/ |
@ -0,0 +1,19 @@ |
||||
root = true |
||||
|
||||
[*] |
||||
indent_style = space |
||||
indent_size = 4 |
||||
end_of_line = lf |
||||
charset = utf-8 |
||||
trim_trailing_whitespace = true |
||||
insert_final_newline = true |
||||
|
||||
[{package.json,*.yml}] |
||||
indent_style = space |
||||
indent_size = 2 |
||||
|
||||
[appveyor.yml] |
||||
end_of_line = crlf |
||||
|
||||
[*.md] |
||||
trim_trailing_whitespace = false |
@ -0,0 +1,110 @@ |
||||
name: Prebuildify, package, publish |
||||
|
||||
on: |
||||
push: |
||||
branches: [ master ] |
||||
pull_request: |
||||
branches: [ master ] |
||||
release: |
||||
types: [ prereleased, released ] |
||||
|
||||
jobs: |
||||
build-linux: |
||||
runs-on: ubuntu-latest |
||||
steps: |
||||
- uses: actions/checkout@v4 |
||||
# This is unsafe, but we really don't use any other native dependencies |
||||
- run: npm ci |
||||
- run: docker run -u $(id -u):$(id -g) -v `pwd`:/input -w /input ghcr.io/prebuild/almalinux-devtoolset11 npx prebuildify --napi --tag-libc --strip --target=node@18.0.0 |
||||
- run: docker run -u $(id -u):$(id -g) -v `pwd`:/input -w /input ghcr.io/prebuild/alpine npx prebuildify --napi --tag-libc --strip --target=node@18.0.0 |
||||
- run: docker run -u $(id -u):$(id -g) -v `pwd`:/input -w /input ghcr.io/prebuild/linux-armv7 npx prebuildify --napi --tag-libc --strip --target=node@18.0.0 |
||||
- run: docker run -u $(id -u):$(id -g) -v `pwd`:/input -w /input ghcr.io/prebuild/linux-armv7l-musl npx prebuildify --napi --tag-libc --strip --target=node@18.0.0 |
||||
- run: docker run -u $(id -u):$(id -g) -v `pwd`:/input -w /input ghcr.io/prebuild/linux-arm64 npx prebuildify --napi --tag-libc --strip --target=node@18.0.0 |
||||
- run: docker run -u $(id -u):$(id -g) -v `pwd`:/input -w /input ghcr.io/prebuild/linux-arm64-musl npx prebuildify --napi --tag-libc --strip --target=node@18.0.0 |
||||
- run: find prebuilds |
||||
- uses: actions/upload-artifact@v4 |
||||
with: |
||||
name: prebuild-linux |
||||
path: ./prebuilds/ |
||||
|
||||
build-windows: |
||||
runs-on: windows-latest |
||||
steps: |
||||
- uses: actions/checkout@v4 |
||||
- uses: actions/setup-node@v4 |
||||
with: |
||||
node-version: 20 |
||||
registry-url: 'https://registry.npmjs.org' |
||||
- run: npm ci |
||||
- run: npx prebuildify --napi --strip --arch=x64 --target=node@18.0.0 |
||||
- run: npx prebuildify --napi --strip --arch=arm64 --target=node@20.0.0 |
||||
- run: dir prebuilds |
||||
- uses: actions/upload-artifact@v4 |
||||
with: |
||||
name: prebuild-windows |
||||
path: ./prebuilds/ |
||||
|
||||
build-macos: |
||||
runs-on: macos-latest |
||||
steps: |
||||
- uses: actions/checkout@v4 |
||||
- uses: actions/setup-node@v4 |
||||
with: |
||||
node-version: 18 |
||||
registry-url: 'https://registry.npmjs.org' |
||||
- run: npm ci |
||||
- run: npx prebuildify --napi --strip --arch=arm64 --target=node@18.0.0 |
||||
- run: npx prebuildify --napi --strip --arch=x64 --target=node@18.0.0 |
||||
- run: find prebuilds |
||||
- uses: actions/upload-artifact@v4 |
||||
with: |
||||
name: prebuild-macos |
||||
path: ./prebuilds/ |
||||
|
||||
pack: |
||||
needs: |
||||
- build-linux |
||||
- build-windows |
||||
- build-macos |
||||
runs-on: ubuntu-latest |
||||
outputs: |
||||
PACK_FILE: ${{ steps.pack.outputs.PACK_FILE }} |
||||
steps: |
||||
- uses: actions/checkout@v4 |
||||
- uses: actions/download-artifact@v4 |
||||
with: |
||||
path: /tmp/prebuilds/ |
||||
- name: Coalesce prebuilds from build matrix |
||||
run: | |
||||
mkdir prebuilds |
||||
for d in /tmp/prebuilds/*; do |
||||
cp -Rav $d/* prebuilds/ |
||||
done |
||||
- run: chmod a+x prebuilds/*/*.node && find prebuilds -executable -type f |
||||
- id: pack |
||||
name: Prepare NPM package |
||||
run: | |
||||
echo "PACK_FILE=$(npm pack)" >> "$GITHUB_OUTPUT" |
||||
- uses: actions/upload-artifact@v4 |
||||
with: |
||||
name: package-tgz |
||||
path: ${{ steps.pack.outputs.PACK_FILE }} |
||||
if-no-files-found: 'error' |
||||
|
||||
test-package: |
||||
needs: pack |
||||
strategy: |
||||
matrix: |
||||
node-version: [ 18, 20, 22, 23 ] |
||||
os: [ ubuntu-latest, windows-latest, macos-latest ] |
||||
runs-on: ${{ matrix.os }} |
||||
steps: |
||||
- uses: actions/setup-node@v4 |
||||
with: |
||||
node-version: ${{ matrix.node-version }} |
||||
registry-url: 'https://registry.npmjs.org' |
||||
- uses: actions/download-artifact@v4 |
||||
with: |
||||
name: package-tgz |
||||
- run: npm install ${{ needs.pack.outputs.PACK_FILE }} |
||||
- run: node -e "const b = require('bcrypt'); const h = b.hashSync('hello', 10); console.log(h, b.compareSync('hello', h))" |
@ -0,0 +1,42 @@ |
||||
name: ci |
||||
|
||||
on: |
||||
push: |
||||
branches: |
||||
- master |
||||
pull_request: |
||||
branches: |
||||
- master |
||||
|
||||
jobs: |
||||
build: |
||||
runs-on: ubuntu-latest |
||||
strategy: |
||||
matrix: |
||||
node-version: [18, 20, 22] |
||||
steps: |
||||
- uses: actions/checkout@v4 |
||||
- name: Use Node.js ${{ matrix.node-version }} |
||||
uses: actions/setup-node@v4 |
||||
with: |
||||
node-version: ${{ matrix.node-version }} |
||||
- run: npm ci |
||||
- name: Test |
||||
run: npm test |
||||
|
||||
build-alpine: |
||||
runs-on: ubuntu-latest |
||||
strategy: |
||||
matrix: |
||||
node-version: [18, 20, 22] |
||||
container: |
||||
image: node:${{ matrix.node-version }}-alpine |
||||
steps: |
||||
- uses: actions/checkout@v4 |
||||
- name: Install dependencies |
||||
run: | |
||||
apk add make g++ python3 |
||||
- run: npm ci |
||||
- name: Test |
||||
run: | |
||||
npm test --unsafe-perm |
@ -0,0 +1,184 @@ |
||||
# 6.0.0 (2025-02-28) |
||||
* Drop support for NodeJS <= 16 |
||||
* Remove `node-pre-gyp` in favor of `prebuildify`, prebuilt binaries are now shipped with the package |
||||
* Update `node-addon-api` to 8.3.0 |
||||
* Update JS code to newer ES syntax |
||||
|
||||
# 5.1.0 (2022-10-06) |
||||
* Update `node-pre-gyp` to 1.0.11 |
||||
|
||||
# 5.1.0 (2022-10-06) |
||||
* Update `node-pre-gyp` to 1.0.10 |
||||
* Replace `nodeunit` with `jest` as the testing library |
||||
|
||||
# 5.0.1 (2021-02-22) |
||||
|
||||
* Update `node-pre-gyp` to 1.0.0 |
||||
|
||||
# 5.0.0 (2020-06-02) |
||||
|
||||
* Fix the bcrypt "wrap-around" bug. It affects passwords with lengths >= 255. |
||||
It is uncommon but it's a bug nevertheless. Previous attempts to fix the bug |
||||
was unsuccessful. |
||||
* Experimental support for z/OS |
||||
* Fix a bug related to NUL in password input |
||||
* Update `node-pre-gyp` to 0.15.0 |
||||
|
||||
# 4.0.1 (2020-02-27) |
||||
|
||||
* Fix compilation errors in Alpine linux |
||||
|
||||
# 4.0.0 (2020-02-17) |
||||
|
||||
* Switch to NAPI bcrypt |
||||
* Drop support for NodeJS 8 |
||||
|
||||
# 3.0.8 (2019-12-31) |
||||
|
||||
* Update `node-pre-gyp` to 0.14 |
||||
* Pre-built binaries for NodeJS 13 |
||||
|
||||
# 3.0.7 (2019-10-18) |
||||
|
||||
* Update `nan` to 2.14.0 |
||||
* Update `node-pre-gyp` to 0.13 |
||||
|
||||
# 3.0.6 (2019-04-11) |
||||
|
||||
* Update `nan` to 2.13.2 |
||||
|
||||
# 3.0.5 (2019-03-19) |
||||
|
||||
* Update `nan` to 2.13.1 |
||||
* NodeJS 12 compatibility |
||||
* Remove `node-pre-gyp` from bundled dependencies |
||||
|
||||
# 3.0.4-napi (2019-03-08) |
||||
|
||||
* Sync N-API bcrypt with NAN bcrypt |
||||
|
||||
# 3.0.4 (2019-02-07) |
||||
|
||||
* Fix GCC, NAN and V8 deprecation warnings |
||||
|
||||
# 3.0.3 (2018-12-19) |
||||
|
||||
* Update `nan` to 2.12.1 |
||||
|
||||
# 3.0.2 (2018-10-18) |
||||
|
||||
* Update `nan` to 2.11.1 |
||||
|
||||
# 3.0.1 (2018-09-20) |
||||
|
||||
* Update `nan` to 2.11.0 |
||||
|
||||
# 3.0.0 (2018-07-06) |
||||
|
||||
* Drop support for NodeJS <= 4 |
||||
|
||||
# 2.0.1 (2018-04-20) |
||||
|
||||
* Update `node-pre-gyp` to allow downloading prebuilt modules |
||||
|
||||
# 2.0.0 (2018-04-07) |
||||
|
||||
* Make `2b` the default bcrypt version |
||||
|
||||
# 1.1.0-napi (2018-01-21) |
||||
|
||||
* Initial support for [N-API](https://nodejs.org/api/n-api.html) |
||||
|
||||
# 1.0.3 (2016-08-23) |
||||
|
||||
* update to nan v2.6.2 for NodeJS 8 support |
||||
* Fix: use npm scripts instead of node-gyp directly. |
||||
|
||||
# 1.0.2 (2016-12-31) |
||||
|
||||
* Fix `compare` promise rejection with invalid arguments |
||||
|
||||
# 1.0.1 (2016-12-07) |
||||
|
||||
* Fix destructuring imports with promises |
||||
|
||||
# 1.0.0 (2016-12-04) |
||||
|
||||
* add Promise support (commit 2488473) |
||||
|
||||
# 0.8.7 (2016-06-09) |
||||
|
||||
* update nan to 2.3.5 for improved node v6 support |
||||
|
||||
# 0.8.6 (2016-04-20) |
||||
|
||||
* update nan for node v6 support |
||||
|
||||
# 0.8.5 (2015-08-12) |
||||
|
||||
* update to nan v2 (adds support for iojs 3) |
||||
|
||||
# 0.8.4 (2015-07-24) |
||||
|
||||
* fix deprecation warning for the Encode API |
||||
|
||||
# 0.8.3 (2015-05-06) |
||||
|
||||
* update nan to 1.8.4 for iojs 2.x support |
||||
|
||||
# 0.8.2 (2015-03-28) |
||||
|
||||
* always use callback for generating random bytes to avoid blocking |
||||
|
||||
# 0.8.1 (2015-01-18) |
||||
* update NaN to 1.5.0 for iojs support |
||||
|
||||
# 0.8.0 (2014-08-03) |
||||
* migrate to NAN for bindings |
||||
|
||||
# v0.5.0 |
||||
* Fix for issue around empty string params throwing Errors. |
||||
* Method deprecation. |
||||
* Upgrade from libeio/ev to libuv. (shtylman) |
||||
** --- NOTE --- Breaks 0.4.x compatability |
||||
* EV_MULTIPLICITY compile flag. |
||||
|
||||
# v0.4.1 |
||||
* Thread safety fix around OpenSSL (GH-32). (bnoordhuis - through node) |
||||
* C++ code changes using delete and new instead of malloc and free. (shtylman) |
||||
* Compile options for speed, zoom. (shtylman) |
||||
* Move much of the type and variable checking to the JS. (shtylman) |
||||
|
||||
# v0.4.0 |
||||
* Added getRounds function that will tell you the number of rounds within a hash/salt |
||||
|
||||
# v0.3.2 |
||||
* Fix api issue with async salt gen first param |
||||
|
||||
# v0.3.1 |
||||
* Compile under node 0.5.x |
||||
|
||||
# v0.3.0 |
||||
* Internal Refactoring |
||||
* Remove pthread dependencies and locking |
||||
* Fix compiler warnings and a memory bug |
||||
|
||||
# v0.2.4 |
||||
* Use threadsafe functions instead of pthread mutexes |
||||
* salt validation to make sure the salt is of the correct size and format |
||||
|
||||
# v0.2.3 |
||||
* cygwin support |
||||
|
||||
# v0.2.2 |
||||
* Remove dependency on libbsd, use libssl instead |
||||
|
||||
# v0.2.0 |
||||
* Added async functionality |
||||
* API changes |
||||
* hashpw -> encrypt |
||||
* all old sync methods now end with _sync |
||||
* Removed libbsd(arc4random) dependency...now uses openssl which is more widely spread |
||||
|
||||
# v0.1.2 |
||||
* Security fix. Wasn't reading rounds in properly and was always only using 4 rounds |
@ -0,0 +1,57 @@ |
||||
# Usage: |
||||
# |
||||
# docker build -t bcryptjs-builder . |
||||
# CONTAINER=$(docker create bcryptjs-builder) |
||||
# # Then copy the artifact to your host: |
||||
# docker cp "$CONTAINER:/usr/local/opt/bcrypt-js/prebuilds" . |
||||
# docker rm "$CONTAINER" |
||||
# |
||||
# Use --platform to build cross-platform i.e. for ARM: |
||||
# |
||||
# docker build -t bcryptjs-builder --platform "linux/arm64/v8" . |
||||
# CONTAINER=$docker create --platform "linux/arm64/v8" bcryptjs-builder) |
||||
# # this copies the prebuilds/linux-arm artifacts |
||||
# docker cp "$CONTAINER:/usr/local/opt/bcrypt-js/prebuilds" . |
||||
# docker rm "$CONTAINER" |
||||
|
||||
|
||||
ARG FROM_IMAGE=node:18-bullseye |
||||
#ARG FROM_IMAGE=arm32v7/node:16-bullseye |
||||
#ARG FROM_IMAGE=arm64v8/node:16-bullseye |
||||
FROM ${FROM_IMAGE} |
||||
|
||||
ENV project bcrypt-js |
||||
ENV DEBIAN_FRONTEND noninteractive |
||||
ENV LC_ALL en_US.UTF-8 |
||||
ENV LANG ${LC_ALL} |
||||
|
||||
RUN echo "#log: ${project}: Setup system" \ |
||||
&& set -x \ |
||||
&& apt-get update -y \ |
||||
&& apt-get install -y \ |
||||
build-essential \ |
||||
python3 \ |
||||
&& apt-get clean \ |
||||
&& update-alternatives --install /usr/local/bin/python python /usr/bin/python3 20 \ |
||||
&& npm i -g prebuildify@5 node-gyp@9 \ |
||||
&& sync |
||||
|
||||
ADD . /usr/local/opt/${project} |
||||
WORKDIR /usr/local/opt/${project} |
||||
|
||||
RUN echo "#log: ${project}: Running build" \ |
||||
&& set -x \ |
||||
&& npm ci \ |
||||
&& npm run build |
||||
|
||||
ARG RUN_TESTS=true |
||||
ARG TEST_TIMEOUT_SECONDS= |
||||
|
||||
RUN if "${RUN_TESTS}"; then \ |
||||
echo "#log ${project}: Running tests" \ |
||||
&& npm test; \ |
||||
else \ |
||||
echo "#log ${project}: Tests were skipped!"; \ |
||||
fi |
||||
|
||||
CMD /bin/bash -l |
@ -0,0 +1,41 @@ |
||||
# Usage: |
||||
# |
||||
# docker build -t bcryptjs-linux-alpine-builder -f Dockerfile-alpine . |
||||
# CONTAINER=$(docker create bcryptjs-linux-alpine-builder) |
||||
# # Then copy the artifact to your host: |
||||
# docker cp "$CONTAINER:/usr/local/opt/bcrypt-js/prebuilds" . |
||||
# docker rm "$CONTAINER" |
||||
|
||||
ARG FROM_IMAGE=node:18-alpine |
||||
FROM ${FROM_IMAGE} |
||||
|
||||
ENV project bcrypt-js |
||||
ENV DEBIAN_FRONTEND noninteractive |
||||
ENV LC_ALL en_US.UTF-8 |
||||
ENV LANG ${LC_ALL} |
||||
|
||||
RUN echo "#log: ${project}: Setup system" \ |
||||
&& set -x \ |
||||
&& apk add --update build-base python3 \ |
||||
&& npm i -g prebuildify@5 node-gyp@9 \ |
||||
&& sync |
||||
|
||||
ADD . /usr/local/opt/${project} |
||||
WORKDIR /usr/local/opt/${project} |
||||
|
||||
RUN echo "#log: ${project}: Running build" \ |
||||
&& set -x \ |
||||
&& npm ci \ |
||||
&& npm run build |
||||
|
||||
ARG RUN_TESTS=true |
||||
ARG TEST_TIMEOUT_SECONDS= |
||||
|
||||
RUN if "${RUN_TESTS}"; then \ |
||||
echo "#log ${project}: Running tests" \ |
||||
&& npm test; \ |
||||
else \ |
||||
echo "#log ${project}: Tests were skipped!"; \ |
||||
fi |
||||
|
||||
CMD /bin/bash -l |
@ -0,0 +1,18 @@ |
||||
Thanks for reporting a new issue with the node bcrypt module! |
||||
|
||||
To help you resolve your issue faster please make sure you have done the following: |
||||
|
||||
* Searched existing issues (even closed ones) for your same problem |
||||
* Make sure you have installed the required dependencies listed on the readme |
||||
* Read your npm error log for lines telling you what failed, usually it is a problem with not having the correct dependencies installed to build the native module |
||||
|
||||
Once you have done the above and are still confident that the issue is with the module, please describe it below. Some things that really help get your issue resolved faster are: |
||||
|
||||
* What went wrong? |
||||
* What did you expect to happen? |
||||
* Which version of nodejs and OS? |
||||
* If you find a bug, please write a failing test. |
||||
|
||||
Thanks! |
||||
|
||||
P.S. If it doesn't look like you read the above then your issue will likely be closed without further explanation. Sorry, but there are just too many issues opened with no useful information or questions which have been previously addressed. |
@ -0,0 +1,19 @@ |
||||
Copyright (c) 2010 Nicholas Campbell |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in |
||||
all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
||||
THE SOFTWARE. |
@ -0,0 +1,19 @@ |
||||
TESTS = test/*.js
|
||||
|
||||
all: test |
||||
|
||||
build: clean compile |
||||
|
||||
compile: |
||||
npm install .
|
||||
npm run install
|
||||
|
||||
test: build |
||||
@./node_modules/.bin/jest \
|
||||
$(TESTS)
|
||||
|
||||
clean: |
||||
rm -Rf lib/bindings/
|
||||
|
||||
|
||||
.PHONY: clean test build |
@ -0,0 +1,388 @@ |
||||
# node.bcrypt.js |
||||
|
||||
[](https://github.com/kelektiv/node.bcrypt.js/actions/workflows/ci.yaml) |
||||
|
||||
[](https://ci.appveyor.com/project/defunctzombie/node-bcrypt-js-pgo26/branch/master) |
||||
|
||||
A library to help you hash passwords. |
||||
|
||||
You can read about [bcrypt in Wikipedia][bcryptwiki] as well as in the following article: |
||||
[How To Safely Store A Password][codahale] |
||||
|
||||
## If You Are Submitting Bugs or Issues |
||||
|
||||
Please verify that the NodeJS version you are using is a _stable_ version; Unstable versions are currently not supported and issues created while using an unstable version will be closed. |
||||
|
||||
If you are on a stable version of NodeJS, please provide a sufficient code snippet or log files for installation issues. The code snippet does not require you to include confidential information. However, it must provide enough information so the problem can be replicable, or it may be closed without an explanation. |
||||
|
||||
|
||||
## Version Compatibility |
||||
|
||||
_Please upgrade to atleast v5.0.0 to avoid security issues mentioned below._ |
||||
|
||||
| Node Version | Bcrypt Version | |
||||
| -------------- | ------------------| |
||||
| 0.4 | <= 0.4 | |
||||
| 0.6, 0.8, 0.10 | >= 0.5 | |
||||
| 0.11 | >= 0.8 | |
||||
| 4 | <= 2.1.0 | |
||||
| 8 | >= 1.0.3 < 4.0.0 | |
||||
| 10, 11 | >= 3 | |
||||
| 12 onwards | >= 3.0.6 | |
||||
|
||||
`node-gyp` only works with stable/released versions of node. Since the `bcrypt` module uses `node-gyp` to build and install, you'll need a stable version of node to use bcrypt. If you do not, you'll likely see an error that starts with: |
||||
|
||||
``` |
||||
gyp ERR! stack Error: "pre" versions of node cannot be installed, use the --nodedir flag instead |
||||
``` |
||||
|
||||
## Security Issues And Concerns |
||||
|
||||
> Per bcrypt implementation, only the first 72 bytes of a string are used. Any extra bytes are ignored when matching passwords. Note that this is not the first 72 *characters*. It is possible for a string to contain less than 72 characters, while taking up more than 72 bytes (e.g. a UTF-8 encoded string containing emojis). If a string is provided, it will be encoded using UTF-8. |
||||
|
||||
As should be the case with any security tool, anyone using this library should scrutinise it. If you find or suspect an issue with the code, please bring it to the maintainers' attention. We will spend some time ensuring that this library is as secure as possible. |
||||
|
||||
Here is a list of BCrypt-related security issues/concerns that have come up over the years. |
||||
|
||||
* An [issue with passwords][jtr] was found with a version of the Blowfish algorithm developed for John the Ripper. This is not present in the OpenBSD version and is thus not a problem for this module. HT [zooko][zooko]. |
||||
* Versions `< 5.0.0` suffer from bcrypt wrap-around bug and _will truncate passwords >= 255 characters leading to severely weakened passwords_. Please upgrade at earliest. See [this wiki page][wrap-around-bug] for more details. |
||||
* Versions `< 5.0.0` _do not handle NUL characters inside passwords properly leading to all subsequent characters being dropped and thus resulting in severely weakened passwords_. Please upgrade at earliest. See [this wiki page][improper-nuls] for more details. |
||||
|
||||
## Compatibility Note |
||||
|
||||
This library supports `$2a$` and `$2b$` prefix bcrypt hashes. `$2x$` and `$2y$` hashes are specific to bcrypt implementation developed for John the Ripper. In theory, they should be compatible with `$2b$` prefix. |
||||
|
||||
Compatibility with hashes generated by other languages is not 100% guaranteed due to difference in character encodings. However, it should not be an issue for most cases. |
||||
|
||||
### Migrating from v1.0.x |
||||
|
||||
Hashes generated in earlier version of `bcrypt` remain 100% supported in `v2.x.x` and later versions. In most cases, the migration should be a bump in the `package.json`. |
||||
|
||||
Hashes generated in `v2.x.x` using the defaults parameters will not work in earlier versions. |
||||
|
||||
## Dependencies |
||||
|
||||
* NodeJS |
||||
* `node-gyp` |
||||
* Please check the dependencies for this tool at: https://github.com/nodejs/node-gyp |
||||
* Windows users will need the options for c# and c++ installed with their visual studio instance. |
||||
* Python 2.x/3.x |
||||
* `OpenSSL` - This is only required to build the `bcrypt` project if you are using versions <= 0.7.7. Otherwise, we're using the builtin node crypto bindings for seed data (which use the same OpenSSL code paths we were, but don't have the external dependency). |
||||
|
||||
## Install via NPM |
||||
|
||||
``` |
||||
npm install bcrypt |
||||
``` |
||||
***Note:*** OS X users using Xcode 4.3.1 or above may need to run the following command in their terminal prior to installing if errors occur regarding xcodebuild: ```sudo xcode-select -switch /Applications/Xcode.app/Contents/Developer``` |
||||
|
||||
_Pre-built binaries for various NodeJS versions are made available on a best-effort basis._ |
||||
|
||||
Only the current stable and supported LTS releases are actively tested against. |
||||
|
||||
_There may be an interval between the release of the module and the availabilty of the compiled modules._ |
||||
|
||||
Currently, we have pre-built binaries that support the following platforms: |
||||
|
||||
1. Windows x32 and x64 |
||||
2. Linux x64 (GlibC and musl) |
||||
3. macOS |
||||
|
||||
If you face an error like this: |
||||
|
||||
``` |
||||
node-pre-gyp ERR! Tried to download(404): https://github.com/kelektiv/node.bcrypt.js/releases/download/v1.0.2/bcrypt_lib-v1.0.2-node-v48-linux-x64.tar.gz |
||||
``` |
||||
|
||||
make sure you have the appropriate dependencies installed and configured for your platform. You can find installation instructions for the dependencies for some common platforms [in this page][depsinstall]. |
||||
|
||||
## Usage |
||||
|
||||
### async (recommended) |
||||
|
||||
```javascript |
||||
const bcrypt = require('bcrypt'); |
||||
const saltRounds = 10; |
||||
const myPlaintextPassword = 's0/\/\P4$$w0rD'; |
||||
const someOtherPlaintextPassword = 'not_bacon'; |
||||
``` |
||||
|
||||
#### To hash a password: |
||||
|
||||
Technique 1 (generate a salt and hash on separate function calls): |
||||
|
||||
```javascript |
||||
bcrypt.genSalt(saltRounds, function(err, salt) { |
||||
bcrypt.hash(myPlaintextPassword, salt, function(err, hash) { |
||||
// Store hash in your password DB. |
||||
}); |
||||
}); |
||||
``` |
||||
|
||||
Technique 2 (auto-gen a salt and hash): |
||||
|
||||
```javascript |
||||
bcrypt.hash(myPlaintextPassword, saltRounds, function(err, hash) { |
||||
// Store hash in your password DB. |
||||
}); |
||||
``` |
||||
|
||||
Note that both techniques achieve the same end-result. |
||||
|
||||
#### To check a password: |
||||
|
||||
```javascript |
||||
// Load hash from your password DB. |
||||
bcrypt.compare(myPlaintextPassword, hash, function(err, result) { |
||||
// result == true |
||||
}); |
||||
bcrypt.compare(someOtherPlaintextPassword, hash, function(err, result) { |
||||
// result == false |
||||
}); |
||||
``` |
||||
|
||||
[A Note on Timing Attacks](#a-note-on-timing-attacks) |
||||
|
||||
### with promises |
||||
|
||||
bcrypt uses whatever `Promise` implementation is available in `global.Promise`. NodeJS >= 0.12 has a native `Promise` implementation built in. However, this should work in any Promises/A+ compliant implementation. |
||||
|
||||
Async methods that accept a callback, return a `Promise` when callback is not specified if Promise support is available. |
||||
|
||||
```javascript |
||||
bcrypt.hash(myPlaintextPassword, saltRounds).then(function(hash) { |
||||
// Store hash in your password DB. |
||||
}); |
||||
``` |
||||
```javascript |
||||
// Load hash from your password DB. |
||||
bcrypt.compare(myPlaintextPassword, hash).then(function(result) { |
||||
// result == true |
||||
}); |
||||
bcrypt.compare(someOtherPlaintextPassword, hash).then(function(result) { |
||||
// result == false |
||||
}); |
||||
``` |
||||
|
||||
This is also compatible with `async/await` |
||||
|
||||
```javascript |
||||
async function checkUser(username, password) { |
||||
//... fetch user from a db etc. |
||||
|
||||
const match = await bcrypt.compare(password, user.passwordHash); |
||||
|
||||
if(match) { |
||||
//login |
||||
} |
||||
|
||||
//... |
||||
} |
||||
``` |
||||
|
||||
### ESM import |
||||
```javascript |
||||
import bcrypt from "bcrypt"; |
||||
|
||||
// later |
||||
await bcrypt.compare(password, hash); |
||||
``` |
||||
|
||||
### sync |
||||
|
||||
```javascript |
||||
const bcrypt = require('bcrypt'); |
||||
const saltRounds = 10; |
||||
const myPlaintextPassword = 's0/\/\P4$$w0rD'; |
||||
const someOtherPlaintextPassword = 'not_bacon'; |
||||
``` |
||||
|
||||
#### To hash a password: |
||||
|
||||
Technique 1 (generate a salt and hash on separate function calls): |
||||
|
||||
```javascript |
||||
const salt = bcrypt.genSaltSync(saltRounds); |
||||
const hash = bcrypt.hashSync(myPlaintextPassword, salt); |
||||
// Store hash in your password DB. |
||||
``` |
||||
|
||||
Technique 2 (auto-gen a salt and hash): |
||||
|
||||
```javascript |
||||
const hash = bcrypt.hashSync(myPlaintextPassword, saltRounds); |
||||
// Store hash in your password DB. |
||||
``` |
||||
|
||||
As with async, both techniques achieve the same end-result. |
||||
|
||||
#### To check a password: |
||||
|
||||
```javascript |
||||
// Load hash from your password DB. |
||||
bcrypt.compareSync(myPlaintextPassword, hash); // true |
||||
bcrypt.compareSync(someOtherPlaintextPassword, hash); // false |
||||
``` |
||||
|
||||
[A Note on Timing Attacks](#a-note-on-timing-attacks) |
||||
|
||||
### Why is async mode recommended over sync mode? |
||||
We recommend using async API if you use `bcrypt` on a server. Bcrypt hashing is CPU intensive which will cause the sync APIs to block the event loop and prevent your application from servicing any inbound requests or events. The async version uses a thread pool which does not block the main event loop. |
||||
|
||||
## API |
||||
|
||||
`BCrypt.` |
||||
|
||||
* `genSaltSync(rounds, minor)` |
||||
* `rounds` - [OPTIONAL] - the cost of processing the data. (default - 10) |
||||
* `minor` - [OPTIONAL] - minor version of bcrypt to use. (default - b) |
||||
* `genSalt(rounds, minor, cb)` |
||||
* `rounds` - [OPTIONAL] - the cost of processing the data. (default - 10) |
||||
* `minor` - [OPTIONAL] - minor version of bcrypt to use. (default - b) |
||||
* `cb` - [OPTIONAL] - a callback to be fired once the salt has been generated. uses eio making it asynchronous. If `cb` is not specified, a `Promise` is returned if Promise support is available. |
||||
* `err` - First parameter to the callback detailing any errors. |
||||
* `salt` - Second parameter to the callback providing the generated salt. |
||||
* `hashSync(data, salt)` |
||||
* `data` - [REQUIRED] - the data to be encrypted. |
||||
* `salt` - [REQUIRED] - the salt to be used to hash the password. if specified as a number then a salt will be generated with the specified number of rounds and used (see example under **Usage**). |
||||
* `hash(data, salt, cb)` |
||||
* `data` - [REQUIRED] - the data to be encrypted. |
||||
* `salt` - [REQUIRED] - the salt to be used to hash the password. if specified as a number then a salt will be generated with the specified number of rounds and used (see example under **Usage**). |
||||
* `cb` - [OPTIONAL] - a callback to be fired once the data has been encrypted. uses eio making it asynchronous. If `cb` is not specified, a `Promise` is returned if Promise support is available. |
||||
* `err` - First parameter to the callback detailing any errors. |
||||
* `encrypted` - Second parameter to the callback providing the encrypted form. |
||||
* `compareSync(data, encrypted)` |
||||
* `data` - [REQUIRED] - data to compare. |
||||
* `encrypted` - [REQUIRED] - data to be compared to. |
||||
* `compare(data, encrypted, cb)` |
||||
* `data` - [REQUIRED] - data to compare. |
||||
* `encrypted` - [REQUIRED] - data to be compared to. |
||||
* `cb` - [OPTIONAL] - a callback to be fired once the data has been compared. uses eio making it asynchronous. If `cb` is not specified, a `Promise` is returned if Promise support is available. |
||||
* `err` - First parameter to the callback detailing any errors. |
||||
* `same` - Second parameter to the callback providing whether the data and encrypted forms match [true | false]. |
||||
* `getRounds(encrypted)` - return the number of rounds used to encrypt a given hash |
||||
* `encrypted` - [REQUIRED] - hash from which the number of rounds used should be extracted. |
||||
|
||||
## A Note on Rounds |
||||
|
||||
A note about the cost: when you are hashing your data, the module will go through a series of rounds to give you a secure hash. The value you submit is not just the number of rounds the module will go through to hash your data. The module will use the value you enter and go through `2^rounds` hashing iterations. |
||||
|
||||
From @garthk, on a 2GHz core you can roughly expect: |
||||
|
||||
rounds=8 : ~40 hashes/sec |
||||
rounds=9 : ~20 hashes/sec |
||||
rounds=10: ~10 hashes/sec |
||||
rounds=11: ~5 hashes/sec |
||||
rounds=12: 2-3 hashes/sec |
||||
rounds=13: ~1 sec/hash |
||||
rounds=14: ~1.5 sec/hash |
||||
rounds=15: ~3 sec/hash |
||||
rounds=25: ~1 hour/hash |
||||
rounds=31: 2-3 days/hash |
||||
|
||||
|
||||
## A Note on Timing Attacks |
||||
|
||||
Because it's come up multiple times in this project and other bcrypt projects, it needs to be said. The `bcrypt` library is not susceptible to timing attacks. From codahale/bcrypt-ruby#42: |
||||
|
||||
> One of the desired properties of a cryptographic hash function is preimage attack resistance, which means there is no shortcut for generating a message which, when hashed, produces a specific digest. |
||||
|
||||
A great thread on this, in much more detail can be found @ codahale/bcrypt-ruby#43 |
||||
|
||||
If you're unfamiliar with timing attacks and want to learn more you can find a great writeup @ [A Lesson In Timing Attacks][timingatk] |
||||
|
||||
However, timing attacks are real. And the comparison function is _not_ time safe. That means that it may exit the function early in the comparison process. Timing attacks happen because of the above. We don't need to be careful that an attacker will learn anything, and our comparison function provides a comparison of hashes. It is a utility to the overall purpose of the library. If you end up using it for something else, we cannot guarantee the security of the comparator. Keep that in mind as you use the library. |
||||
|
||||
## Hash Info |
||||
|
||||
The characters that comprise the resultant hash are `./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$`. |
||||
|
||||
Resultant hashes will be 60 characters long and they will include the salt among other parameters, as follows: |
||||
|
||||
`$[algorithm]$[cost]$[salt][hash]` |
||||
|
||||
- 2 chars hash algorithm identifier prefix. `"$2a$" or "$2b$"` indicates BCrypt |
||||
- Cost-factor (n). Represents the exponent used to determine how many iterations 2^n |
||||
- 16-byte (128-bit) salt, base64 encoded to 22 characters |
||||
- 24-byte (192-bit) hash, base64 encoded to 31 characters |
||||
|
||||
Example: |
||||
``` |
||||
$2b$10$nOUIs5kJ7naTuTFkBy1veuK0kSxUFXfuaOKdOKf9xYT0KKIGSJwFa |
||||
| | | | |
||||
| | | hash-value = K0kSxUFXfuaOKdOKf9xYT0KKIGSJwFa |
||||
| | | |
||||
| | salt = nOUIs5kJ7naTuTFkBy1veu |
||||
| | |
||||
| cost-factor => 10 = 2^10 rounds |
||||
| |
||||
hash-algorithm identifier => 2b = BCrypt |
||||
``` |
||||
|
||||
## Testing |
||||
|
||||
If you create a pull request, tests better pass :) |
||||
|
||||
``` |
||||
npm install |
||||
npm test |
||||
``` |
||||
|
||||
## Credits |
||||
|
||||
The code for this comes from a few sources: |
||||
|
||||
* blowfish.cc - OpenBSD |
||||
* bcrypt.cc - OpenBSD |
||||
* bcrypt::gen_salt - [gen_salt inclusion to bcrypt][bcryptgs] |
||||
* bcrypt_node.cc - me |
||||
|
||||
## Contributors |
||||
|
||||
* [Antonio Salazar Cardozo][shadowfiend] - Early MacOS X support (when we used libbsd) |
||||
* [Ben Glow][pixelglow] - Fixes for thread safety with async calls |
||||
* [Van Nguyen][thegoleffect] - Found a timing attack in the comparator |
||||
* [NewITFarmer][newitfarmer] - Initial Cygwin support |
||||
* [David Trejo][dtrejo] - packaging fixes |
||||
* [Alfred Westerveld][alfredwesterveld] - packaging fixes |
||||
* [Vincent Côté-Roy][vincentr] - Testing around concurrency issues |
||||
* [Lloyd Hilaiel][lloyd] - Documentation fixes |
||||
* [Roman Shtylman][shtylman] - Code refactoring, general rot reduction, compile options, better memory management with delete and new, and an upgrade to libuv over eio/ev. |
||||
* [Vadim Graboys][vadimg] - Code changes to support 0.5.5+ |
||||
* [Ben Noordhuis][bnoordhuis] - Fixed a thread safety issue in nodejs that was perfectly mappable to this module. |
||||
* [Nate Rajlich][tootallnate] - Bindings and build process. |
||||
* [Sean McArthur][seanmonstar] - Windows Support |
||||
* [Fanie Oosthuysen][weareu] - Windows Support |
||||
* [Amitosh Swain Mahapatra][recrsn] - $2b$ hash support, ES6 Promise support |
||||
* [Nicola Del Gobbo][NickNaso] - Initial implementation with N-API |
||||
|
||||
## License |
||||
Unless stated elsewhere, file headers or otherwise, the license as stated in the LICENSE file. |
||||
|
||||
[bcryptwiki]: https://en.wikipedia.org/wiki/Bcrypt |
||||
[bcryptgs]: http://mail-index.netbsd.org/tech-crypto/2002/05/24/msg000204.html |
||||
[codahale]: http://codahale.com/how-to-safely-store-a-password/ |
||||
[gh13]: https://github.com/ncb000gt/node.bcrypt.js/issues/13 |
||||
[jtr]: http://www.openwall.com/lists/oss-security/2011/06/20/2 |
||||
[depsinstall]: https://github.com/kelektiv/node.bcrypt.js/wiki/Installation-Instructions |
||||
[timingatk]: https://codahale.com/a-lesson-in-timing-attacks/ |
||||
[wrap-around-bug]: https://github.com/kelektiv/node.bcrypt.js/wiki/Security-Issues-and-Concerns#bcrypt-wrap-around-bug-medium-severity |
||||
[improper-nuls]: https://github.com/kelektiv/node.bcrypt.js/wiki/Security-Issues-and-Concerns#improper-nul-handling-medium-severity |
||||
|
||||
[shadowfiend]:https://github.com/Shadowfiend |
||||
[thegoleffect]:https://github.com/thegoleffect |
||||
[pixelglow]:https://github.com/pixelglow |
||||
[dtrejo]:https://github.com/dtrejo |
||||
[alfredwesterveld]:https://github.com/alfredwesterveld |
||||
[newitfarmer]:https://github.com/newitfarmer |
||||
[zooko]:https://twitter.com/zooko |
||||
[vincentr]:https://twitter.com/vincentcr |
||||
[lloyd]:https://github.com/lloyd |
||||
[shtylman]:https://github.com/shtylman |
||||
[vadimg]:https://github.com/vadimg |
||||
[bnoordhuis]:https://github.com/bnoordhuis |
||||
[tootallnate]:https://github.com/tootallnate |
||||
[seanmonstar]:https://github.com/seanmonstar |
||||
[weareu]:https://github.com/weareu |
||||
[recrsn]:https://github.com/recrsn |
||||
[NickNaso]: https://github.com/NickNaso |
@ -0,0 +1,15 @@ |
||||
# Security Policy |
||||
|
||||
As with any software, `bcrypt` is likely to have bugs. Please report any security vulnerabilities responsibly |
||||
|
||||
## Supported Versions |
||||
|
||||
| Version | Supported | |
||||
| ------- | ------------------ | |
||||
| 5.0.x | :white_check_mark: | |
||||
| < 5.0 | :x: | |
||||
|
||||
## Reporting a Vulnerability |
||||
|
||||
If you are reporting a security vulnerability, please refrain from opening a GitHub issue and instead mail it to |
||||
one of the maintainers listed in the README. |
@ -0,0 +1,242 @@ |
||||
const path = require('path'); |
||||
const bindings = require('node-gyp-build')(path.resolve(__dirname)); |
||||
|
||||
const crypto = require('crypto'); |
||||
|
||||
const promises = require('./promises'); |
||||
|
||||
/// generate a salt (sync)
|
||||
/// @param {Number} [rounds] number of rounds (default 10)
|
||||
/// @return {String} salt
|
||||
function genSaltSync(rounds, minor) { |
||||
// default 10 rounds
|
||||
if (!rounds) { |
||||
rounds = 10; |
||||
} else if (typeof rounds !== 'number') { |
||||
throw new Error('rounds must be a number'); |
||||
} |
||||
|
||||
if (!minor) { |
||||
minor = 'b'; |
||||
} else if (minor !== 'b' && minor !== 'a') { |
||||
throw new Error('minor must be either "a" or "b"'); |
||||
} |
||||
|
||||
return bindings.gen_salt_sync(minor, rounds, crypto.randomBytes(16)); |
||||
} |
||||
|
||||
/// generate a salt
|
||||
/// @param {Number} [rounds] number of rounds (default 10)
|
||||
/// @param {Function} cb callback(err, salt)
|
||||
function genSalt(rounds, minor, cb) { |
||||
let error; |
||||
|
||||
// if callback is first argument, then use defaults for others
|
||||
if (typeof arguments[0] === 'function') { |
||||
// have to set callback first otherwise arguments are overridden
|
||||
cb = arguments[0]; |
||||
rounds = 10; |
||||
minor = 'b'; |
||||
// callback is second argument
|
||||
} else if (typeof arguments[1] === 'function') { |
||||
// have to set callback first otherwise arguments are overridden
|
||||
cb = arguments[1]; |
||||
minor = 'b'; |
||||
} |
||||
|
||||
if (!cb) { |
||||
return promises.promise(genSalt, this, [rounds, minor]); |
||||
} |
||||
|
||||
// default 10 rounds
|
||||
if (!rounds) { |
||||
rounds = 10; |
||||
} else if (typeof rounds !== 'number') { |
||||
// callback error asynchronously
|
||||
error = new Error('rounds must be a number'); |
||||
return process.nextTick(function () { |
||||
cb(error); |
||||
}); |
||||
} |
||||
|
||||
if (!minor) { |
||||
minor = 'b' |
||||
} else if (minor !== 'b' && minor !== 'a') { |
||||
error = new Error('minor must be either "a" or "b"'); |
||||
return process.nextTick(function () { |
||||
cb(error); |
||||
}); |
||||
} |
||||
|
||||
crypto.randomBytes(16, function (error, randomBytes) { |
||||
if (error) { |
||||
cb(error); |
||||
return; |
||||
} |
||||
|
||||
bindings.gen_salt(minor, rounds, randomBytes, cb); |
||||
}); |
||||
} |
||||
|
||||
/// hash data using a salt
|
||||
/// @param {String|Buffer} data the data to encrypt
|
||||
/// @param {String} salt the salt to use when hashing
|
||||
/// @return {String} hash
|
||||
function hashSync(data, salt) { |
||||
if (data == null || salt == null) { |
||||
throw new Error('data and salt arguments required'); |
||||
} |
||||
|
||||
if (!(typeof data === 'string' || data instanceof Buffer) || (typeof salt !== 'string' && typeof salt !== 'number')) { |
||||
throw new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds'); |
||||
} |
||||
|
||||
if (typeof salt === 'number') { |
||||
salt = module.exports.genSaltSync(salt); |
||||
} |
||||
|
||||
return bindings.encrypt_sync(data, salt); |
||||
} |
||||
|
||||
/// hash data using a salt
|
||||
/// @param {String|Buffer} data the data to encrypt
|
||||
/// @param {String} salt the salt to use when hashing
|
||||
/// @param {Function} cb callback(err, hash)
|
||||
function hash(data, salt, cb) { |
||||
let error; |
||||
|
||||
if (typeof data === 'function') { |
||||
error = new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds'); |
||||
return process.nextTick(function () { |
||||
data(error); |
||||
}); |
||||
} |
||||
|
||||
if (typeof salt === 'function') { |
||||
error = new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds'); |
||||
return process.nextTick(function () { |
||||
salt(error); |
||||
}); |
||||
} |
||||
|
||||
// cb exists but is not a function
|
||||
// return a rejecting promise
|
||||
if (cb && typeof cb !== 'function') { |
||||
return promises.reject(new Error('cb must be a function or null to return a Promise')); |
||||
} |
||||
|
||||
if (!cb) { |
||||
return promises.promise(hash, this, [data, salt]); |
||||
} |
||||
|
||||
if (data == null || salt == null) { |
||||
error = new Error('data and salt arguments required'); |
||||
return process.nextTick(function () { |
||||
cb(error); |
||||
}); |
||||
} |
||||
|
||||
if (!(typeof data === 'string' || data instanceof Buffer) || (typeof salt !== 'string' && typeof salt !== 'number')) { |
||||
error = new Error('data must be a string or Buffer and salt must either be a salt string or a number of rounds'); |
||||
return process.nextTick(function () { |
||||
cb(error); |
||||
}); |
||||
} |
||||
|
||||
|
||||
if (typeof salt === 'number') { |
||||
return module.exports.genSalt(salt, function (err, salt) { |
||||
return bindings.encrypt(data, salt, cb); |
||||
}); |
||||
} |
||||
|
||||
return bindings.encrypt(data, salt, cb); |
||||
} |
||||
|
||||
/// compare raw data to hash
|
||||
/// @param {String|Buffer} data the data to hash and compare
|
||||
/// @param {String} hash expected hash
|
||||
/// @return {bool} true if hashed data matches hash
|
||||
function compareSync(data, hash) { |
||||
if (data == null || hash == null) { |
||||
throw new Error('data and hash arguments required'); |
||||
} |
||||
|
||||
if (!(typeof data === 'string' || data instanceof Buffer) || typeof hash !== 'string') { |
||||
throw new Error('data must be a string or Buffer and hash must be a string'); |
||||
} |
||||
|
||||
return bindings.compare_sync(data, hash); |
||||
} |
||||
|
||||
/// compare raw data to hash
|
||||
/// @param {String|Buffer} data the data to hash and compare
|
||||
/// @param {String} hash expected hash
|
||||
/// @param {Function} cb callback(err, matched) - matched is true if hashed data matches hash
|
||||
function compare(data, hash, cb) { |
||||
let error; |
||||
|
||||
if (typeof data === 'function') { |
||||
error = new Error('data and hash arguments required'); |
||||
return process.nextTick(function () { |
||||
data(error); |
||||
}); |
||||
} |
||||
|
||||
if (typeof hash === 'function') { |
||||
error = new Error('data and hash arguments required'); |
||||
return process.nextTick(function () { |
||||
hash(error); |
||||
}); |
||||
} |
||||
|
||||
// cb exists but is not a function
|
||||
// return a rejecting promise
|
||||
if (cb && typeof cb !== 'function') { |
||||
return promises.reject(new Error('cb must be a function or null to return a Promise')); |
||||
} |
||||
|
||||
if (!cb) { |
||||
return promises.promise(compare, this, [data, hash]); |
||||
} |
||||
|
||||
if (data == null || hash == null) { |
||||
error = new Error('data and hash arguments required'); |
||||
return process.nextTick(function () { |
||||
cb(error); |
||||
}); |
||||
} |
||||
|
||||
if (!(typeof data === 'string' || data instanceof Buffer) || typeof hash !== 'string') { |
||||
error = new Error('data and hash must be strings'); |
||||
return process.nextTick(function () { |
||||
cb(error); |
||||
}); |
||||
} |
||||
|
||||
return bindings.compare(data, hash, cb); |
||||
} |
||||
|
||||
/// @param {String} hash extract rounds from this hash
|
||||
/// @return {Number} the number of rounds used to encrypt a given hash
|
||||
function getRounds(hash) { |
||||
if (hash == null) { |
||||
throw new Error('hash argument required'); |
||||
} |
||||
|
||||
if (typeof hash !== 'string') { |
||||
throw new Error('hash must be a string'); |
||||
} |
||||
|
||||
return bindings.get_rounds(hash); |
||||
} |
||||
|
||||
module.exports = { |
||||
genSaltSync, |
||||
genSalt, |
||||
hashSync, |
||||
hash, |
||||
compareSync, |
||||
compare, |
||||
getRounds, |
||||
} |
@ -0,0 +1,49 @@ |
||||
{ |
||||
"variables": { |
||||
"NODE_VERSION%":"<!(node -p \"process.versions.node.split(\\\".\\\")[0]\")" |
||||
}, |
||||
'targets': [ |
||||
{ |
||||
'target_name': 'bcrypt_lib', |
||||
'sources': [ |
||||
'src/blowfish.cc', |
||||
'src/bcrypt.cc', |
||||
'src/bcrypt_node.cc' |
||||
], |
||||
'defines': [ |
||||
'_GNU_SOURCE', |
||||
], |
||||
'cflags!': [ '-fno-exceptions' ], |
||||
'cflags_cc!': [ '-fno-exceptions' ], |
||||
'dependencies': [ |
||||
"<!(node -p \"require('node-addon-api').targets\"):node_addon_api_except", |
||||
], |
||||
'conditions': [ |
||||
['OS=="win"', { |
||||
"msvs_settings": { |
||||
"VCCLCompilerTool": { |
||||
"ExceptionHandling": 1 |
||||
} |
||||
}, |
||||
'defines': [ |
||||
'uint=unsigned int', |
||||
] |
||||
}], |
||||
['OS=="mac"', { |
||||
'cflags+': ['-fvisibility=hidden'], |
||||
"xcode_settings": { |
||||
"CLANG_CXX_LIBRARY": "libc++", |
||||
'GCC_ENABLE_CPP_EXCEPTIONS': 'YES', |
||||
'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES', # -fvisibility=hidden |
||||
} |
||||
}], |
||||
['OS=="zos" and NODE_VERSION <= 16',{ |
||||
'cflags': [ |
||||
'-qascii', |
||||
], |
||||
'defines': ["NAPI_DISABLE_CPP_EXCEPTIONS"], |
||||
}], |
||||
], |
||||
}, |
||||
] |
||||
} |
@ -0,0 +1,37 @@ |
||||
#!/bin/bash -ue |
||||
|
||||
CLEAN=${CLEAN:-""} |
||||
RUN_TESTS=${RUN_TESTS:-true} |
||||
|
||||
if [ -n "$CLEAN" ]; then |
||||
rm -rf build build-tmp* |
||||
rm -rf lib/binding |
||||
rm -rf prebuilds |
||||
fi |
||||
|
||||
npm i -g prebuildify@5 node-gyp@9 |
||||
npm ci |
||||
#npm run build |
||||
|
||||
for PLATFORM in linux/amd64 linux/arm64/v8 linux/arm/v7; do |
||||
echo -- build for $PLATFORM -- |
||||
BUILDER_NAME="bcryptjs-${PLATFORM//\/-}-builder" |
||||
docker build -t "$BUILDER_NAME" \ |
||||
--build-arg RUN_TESTS="$RUN_TESTS" \ |
||||
--platform "$PLATFORM" . |
||||
CONTAINER=$(docker create --platform "$PLATFORM" "$BUILDER_NAME") |
||||
docker cp "$CONTAINER:/usr/local/opt/bcrypt-js/prebuilds" . |
||||
docker rm "$CONTAINER" |
||||
|
||||
echo -- build for $PLATFORM Alpine -- |
||||
BUILDER_NAME="bcryptjs-${PLATFORM//\/-}-alpine-builder" |
||||
docker build -t "$BUILDER_NAME" -f Dockerfile-alpine \ |
||||
--build-arg RUN_TESTS="$RUN_TESTS" \ |
||||
--platform "$PLATFORM" . |
||||
CONTAINER=$(docker create --platform "$PLATFORM" "$BUILDER_NAME") |
||||
docker cp "$CONTAINER:/usr/local/opt/bcrypt-js/prebuilds" . |
||||
docker rm "$CONTAINER" |
||||
|
||||
done |
||||
|
||||
ls -lF prebuilds/ |
@ -0,0 +1,28 @@ |
||||
const bcrypt = require('../bcrypt'); |
||||
|
||||
(async () => { |
||||
const start = Date.now(); |
||||
|
||||
// genSalt
|
||||
const salt = await bcrypt.genSalt(10) |
||||
console.log('salt: ' + salt); |
||||
console.log('salt cb end: ' + (Date.now() - start) + 'ms'); |
||||
|
||||
// hash
|
||||
const crypted = await bcrypt.hash('test', salt) |
||||
console.log('crypted: ' + crypted); |
||||
console.log('crypted cb end: ' + (Date.now() - start) + 'ms'); |
||||
console.log('rounds used from hash:', bcrypt.getRounds(crypted)); |
||||
|
||||
// compare
|
||||
const res = await bcrypt.compare('test', crypted) |
||||
console.log('compared true: ' + res); |
||||
console.log('compared true cb end: ' + (Date.now() - start) + 'ms'); |
||||
|
||||
// compare
|
||||
const res2 = await bcrypt.compare('bacon', crypted) |
||||
console.log('compared false: ' + res2); |
||||
console.log('compared false cb end: ' + (Date.now() - start) + 'ms'); |
||||
|
||||
console.log('end: ' + (Date.now() - start) + 'ms'); |
||||
})(); |
@ -0,0 +1,8 @@ |
||||
const bcrypt = require('../bcrypt'); |
||||
|
||||
(function printSalt() { |
||||
bcrypt.genSalt(10, (err, salt) => { |
||||
console.log('salt: ' + salt); |
||||
printSalt(); |
||||
}); |
||||
})() |
@ -0,0 +1,62 @@ |
||||
{ |
||||
"name": "bcrypt", |
||||
"description": "A bcrypt library for NodeJS.", |
||||
"keywords": [ |
||||
"bcrypt", |
||||
"password", |
||||
"auth", |
||||
"authentication", |
||||
"encryption", |
||||
"crypt", |
||||
"crypto" |
||||
], |
||||
"main": "./bcrypt", |
||||
"version": "6.0.0", |
||||
"author": "Nick Campbell (https://github.com/ncb000gt)", |
||||
"engines": { |
||||
"node": ">= 18" |
||||
}, |
||||
"repository": { |
||||
"type": "git", |
||||
"url": "https://github.com/kelektiv/node.bcrypt.js.git" |
||||
}, |
||||
"license": "MIT", |
||||
"bugs": { |
||||
"url": "https://github.com/kelektiv/node.bcrypt.js/issues" |
||||
}, |
||||
"scripts": { |
||||
"test": "jest", |
||||
"install": "node-gyp-build", |
||||
"build": "prebuildify --napi --tag-libc --strip" |
||||
}, |
||||
"dependencies": { |
||||
"node-addon-api": "^8.3.0", |
||||
"node-gyp-build": "^4.8.4" |
||||
}, |
||||
"devDependencies": { |
||||
"jest": "^29.7.0", |
||||
"prebuildify": "^6.0.1" |
||||
}, |
||||
"contributors": [ |
||||
"Antonio Salazar Cardozo <savedfastcool@gmail.com> (https://github.com/Shadowfiend)", |
||||
"Van Nguyen <the.gol.effect@gmail.com> (https://github.com/thegoleffect)", |
||||
"David Trejo <david@dtrejo.com> (https://github.com/dtrejo)", |
||||
"Ben Glow <glen.low@pixelglow.com> (https://github.com/pixelglow)", |
||||
"NewITFarmer.com <> (https://github.com/newitfarmer)", |
||||
"Alfred Westerveld <alfredwesterveld@gmail.com> (https://github.com/alfredwesterveld)", |
||||
"Vincent Côté-Roy <vincentcr@gmail.com> (https://github.com/vincentcr)", |
||||
"Lloyd Hilaiel <lloyd@hilaiel.com> (https://github.com/lloyd)", |
||||
"Roman Shtylman <shtylman@gmail.com> (https://github.com/shtylman)", |
||||
"Vadim Graboys <dimva13@gmail.com> (https://github.com/vadimg)", |
||||
"Ben Noorduis <> (https://github.com/bnoordhuis)", |
||||
"Nate Rajlich <nathan@tootallnate.net> (https://github.com/tootallnate)", |
||||
"Sean McArthur <sean.monstar@gmail.com> (https://github.com/seanmonstar)", |
||||
"Fanie Oosthuysen <fanie.oosthuysen@gmail.com> (https://github.com/weareu)", |
||||
"Amitosh Swain Mahapatra <amitosh.swain@gmail.com> (https://github.com/Agathver)", |
||||
"Corbin Crutchley <crutchcorn@gmail.com> (https://github.com/crutchcorn)", |
||||
"Nicola Del Gobbo <nicoladelgobbo@gmail.com> (https://github.com/NickNaso)" |
||||
], |
||||
"binary": { |
||||
"module_name": "bcrypt_lib" |
||||
} |
||||
} |
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -0,0 +1,45 @@ |
||||
let Promise = global.Promise; |
||||
|
||||
/// encapsulate a method with a node-style callback in a Promise
|
||||
/// @param {object} 'this' of the encapsulated function
|
||||
/// @param {function} function to be encapsulated
|
||||
/// @param {Array-like} args to be passed to the called function
|
||||
/// @return {Promise} a Promise encapsulating the function
|
||||
function promise(fn, context, args) { |
||||
if (!Array.isArray(args)) { |
||||
args = Array.prototype.slice.call(args); |
||||
} |
||||
|
||||
if (typeof fn !== 'function') { |
||||
return Promise.reject(new Error('fn must be a function')); |
||||
} |
||||
|
||||
return new Promise((resolve, reject) => { |
||||
args.push((err, data) => { |
||||
if (err) { |
||||
reject(err); |
||||
} else { |
||||
resolve(data); |
||||
} |
||||
}); |
||||
|
||||
fn.apply(context, args); |
||||
}); |
||||
} |
||||
|
||||
/// @param {err} the error to be thrown
|
||||
function reject(err) { |
||||
return Promise.reject(err); |
||||
} |
||||
|
||||
/// changes the promise implementation that bcrypt uses
|
||||
/// @param {Promise} the implementation to use
|
||||
function use(promise) { |
||||
Promise = promise; |
||||
} |
||||
|
||||
module.exports = { |
||||
promise, |
||||
reject, |
||||
use |
||||
} |
@ -0,0 +1,315 @@ |
||||
/* $OpenBSD: bcrypt.c,v 1.31 2014/03/22 23:02:03 tedu Exp $ */ |
||||
|
||||
/*
|
||||
* Copyright (c) 1997 Niels Provos <provos@umich.edu> |
||||
* |
||||
* Permission to use, copy, modify, and distribute this software for any |
||||
* purpose with or without fee is hereby granted, provided that the above |
||||
* copyright notice and this permission notice appear in all copies. |
||||
* |
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
||||
*/ |
||||
|
||||
/* This password hashing algorithm was designed by David Mazieres
|
||||
* <dm@lcs.mit.edu> and works as follows: |
||||
* |
||||
* 1. state := InitState () |
||||
* 2. state := ExpandKey (state, salt, password) |
||||
* 3. REPEAT rounds: |
||||
* state := ExpandKey (state, 0, password) |
||||
* state := ExpandKey (state, 0, salt) |
||||
* 4. ctext := "OrpheanBeholderScryDoubt" |
||||
* 5. REPEAT 64: |
||||
* ctext := Encrypt_ECB (state, ctext); |
||||
* 6. RETURN Concatenate (salt, ctext); |
||||
* |
||||
*/ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <sys/types.h> |
||||
#include <string.h> |
||||
|
||||
#include "node_blf.h" |
||||
|
||||
#ifdef _WIN32 |
||||
#define snprintf _snprintf |
||||
#endif |
||||
|
||||
//#if !defined(__APPLE__) && !defined(__MACH__)
|
||||
//#include "bsd/stdlib.h"
|
||||
//#endif
|
||||
|
||||
/* This implementation is adaptable to current computing power.
|
||||
* You can have up to 2^31 rounds which should be enough for some |
||||
* time to come. |
||||
*/ |
||||
|
||||
static void encode_base64(u_int8_t *, u_int8_t *, u_int16_t); |
||||
static void decode_base64(u_int8_t *, u_int16_t, u_int8_t *); |
||||
|
||||
const static char* error = ":"; |
||||
|
||||
const static u_int8_t Base64Code[] = |
||||
"./ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; |
||||
|
||||
const static u_int8_t index_64[128] = { |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 255, 255, 255, 255, |
||||
255, 255, 255, 255, 255, 255, 0, 1, 54, 55, |
||||
56, 57, 58, 59, 60, 61, 62, 63, 255, 255, |
||||
255, 255, 255, 255, 255, 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, |
||||
255, 255, 255, 255, 255, 255, 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, 255, 255, 255, 255, 255 |
||||
}; |
||||
#define CHAR64(c) ( (c) > 127 ? 255 : index_64[(c)]) |
||||
|
||||
static void |
||||
decode_base64(u_int8_t *buffer, u_int16_t len, u_int8_t *data) |
||||
{ |
||||
u_int8_t *bp = buffer; |
||||
u_int8_t *p = data; |
||||
u_int8_t c1, c2, c3, c4; |
||||
while (bp < buffer + len) { |
||||
c1 = CHAR64(*p); |
||||
c2 = CHAR64(*(p + 1)); |
||||
|
||||
/* Invalid data */ |
||||
if (c1 == 255 || c2 == 255) |
||||
break; |
||||
|
||||
*bp++ = (c1 << 2) | ((c2 & 0x30) >> 4); |
||||
if (bp >= buffer + len) |
||||
break; |
||||
|
||||
c3 = CHAR64(*(p + 2)); |
||||
if (c3 == 255) |
||||
break; |
||||
|
||||
*bp++ = ((c2 & 0x0f) << 4) | ((c3 & 0x3c) >> 2); |
||||
if (bp >= buffer + len) |
||||
break; |
||||
|
||||
c4 = CHAR64(*(p + 3)); |
||||
if (c4 == 255) |
||||
break; |
||||
*bp++ = ((c3 & 0x03) << 6) | c4; |
||||
|
||||
p += 4; |
||||
} |
||||
} |
||||
|
||||
void |
||||
encode_salt(char *salt, u_int8_t *csalt, char minor, u_int16_t clen, u_int8_t logr) |
||||
{ |
||||
salt[0] = '$'; |
||||
salt[1] = BCRYPT_VERSION; |
||||
salt[2] = minor; |
||||
salt[3] = '$'; |
||||
|
||||
// Max rounds are 31
|
||||
snprintf(salt + 4, 4, "%2.2u$", logr & 0x001F); |
||||
|
||||
encode_base64((u_int8_t *) salt + 7, csalt, clen); |
||||
} |
||||
|
||||
|
||||
/* Generates a salt for this version of crypt.
|
||||
Since versions may change. Keeping this here |
||||
seems sensible. |
||||
from: http://mail-index.netbsd.org/tech-crypto/2002/05/24/msg000204.html
|
||||
*/ |
||||
void |
||||
bcrypt_gensalt(char minor, u_int8_t log_rounds, u_int8_t *seed, char *gsalt) |
||||
{ |
||||
if (log_rounds < 4) |
||||
log_rounds = 4; |
||||
else if (log_rounds > 31) |
||||
log_rounds = 31; |
||||
|
||||
encode_salt(gsalt, seed, minor, BCRYPT_MAXSALT, log_rounds); |
||||
} |
||||
|
||||
/* We handle $Vers$log2(NumRounds)$salt+passwd$
|
||||
i.e. $2$04$iwouldntknowwhattosayetKdJ6iFtacBqJdKe6aW7ou */ |
||||
|
||||
void |
||||
bcrypt(const char *key, size_t key_len, const char *salt, char *encrypted) |
||||
{ |
||||
blf_ctx state; |
||||
u_int32_t rounds, i, k; |
||||
u_int16_t j; |
||||
u_int8_t salt_len, logr, minor; |
||||
u_int8_t ciphertext[4 * BCRYPT_BLOCKS+1] = "OrpheanBeholderScryDoubt"; |
||||
u_int8_t csalt[BCRYPT_MAXSALT]; |
||||
u_int32_t cdata[BCRYPT_BLOCKS]; |
||||
int n; |
||||
|
||||
/* Discard "$" identifier */ |
||||
salt++; |
||||
|
||||
if (*salt > BCRYPT_VERSION) { |
||||
/* How do I handle errors ? Return ':' */ |
||||
strcpy(encrypted, error); |
||||
return; |
||||
} |
||||
|
||||
/* Check for minor versions */ |
||||
if (salt[1] != '$') { |
||||
switch (salt[1]) { |
||||
case 'a': /* 'ab' should not yield the same as 'abab' */ |
||||
case 'b': /* cap input length at 72 bytes */ |
||||
minor = salt[1]; |
||||
salt++; |
||||
break; |
||||
default: |
||||
strcpy(encrypted, error); |
||||
return; |
||||
} |
||||
} else |
||||
minor = 0; |
||||
|
||||
/* Discard version + "$" identifier */ |
||||
salt += 2; |
||||
|
||||
if (salt[2] != '$') { |
||||
/* Out of sync with passwd entry */ |
||||
strcpy(encrypted, error); |
||||
return; |
||||
} |
||||
|
||||
/* Computer power doesn't increase linear, 2^x should be fine */ |
||||
n = atoi(salt); |
||||
if (n > 31 || n < 0) { |
||||
strcpy(encrypted, error); |
||||
return; |
||||
} |
||||
logr = (u_int8_t)n; |
||||
if ((rounds = (u_int32_t) 1 << logr) < BCRYPT_MINROUNDS) { |
||||
strcpy(encrypted, error); |
||||
return; |
||||
} |
||||
|
||||
/* Discard num rounds + "$" identifier */ |
||||
salt += 3; |
||||
|
||||
if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT) { |
||||
strcpy(encrypted, error); |
||||
return; |
||||
} |
||||
|
||||
/* We dont want the base64 salt but the raw data */ |
||||
decode_base64(csalt, BCRYPT_MAXSALT, (u_int8_t *) salt); |
||||
salt_len = BCRYPT_MAXSALT; |
||||
if (minor <= 'a') |
||||
key_len = (u_int8_t)(key_len + (minor >= 'a' ? 1 : 0)); |
||||
else |
||||
{ |
||||
/* cap key_len at the actual maximum supported
|
||||
* length here to avoid integer wraparound */ |
||||
if (key_len > 72) |
||||
key_len = 72; |
||||
key_len++; /* include the NUL */ |
||||
} |
||||
|
||||
|
||||
/* Setting up S-Boxes and Subkeys */ |
||||
Blowfish_initstate(&state); |
||||
Blowfish_expandstate(&state, csalt, salt_len, |
||||
(u_int8_t *) key, key_len); |
||||
for (k = 0; k < rounds; k++) { |
||||
Blowfish_expand0state(&state, (u_int8_t *) key, key_len); |
||||
Blowfish_expand0state(&state, csalt, salt_len); |
||||
} |
||||
|
||||
/* This can be precomputed later */ |
||||
j = 0; |
||||
for (i = 0; i < BCRYPT_BLOCKS; i++) |
||||
cdata[i] = Blowfish_stream2word(ciphertext, 4 * BCRYPT_BLOCKS, &j); |
||||
|
||||
/* Now do the encryption */ |
||||
for (k = 0; k < 64; k++) |
||||
blf_enc(&state, cdata, BCRYPT_BLOCKS / 2); |
||||
|
||||
for (i = 0; i < BCRYPT_BLOCKS; i++) { |
||||
ciphertext[4 * i + 3] = cdata[i] & 0xff; |
||||
cdata[i] = cdata[i] >> 8; |
||||
ciphertext[4 * i + 2] = cdata[i] & 0xff; |
||||
cdata[i] = cdata[i] >> 8; |
||||
ciphertext[4 * i + 1] = cdata[i] & 0xff; |
||||
cdata[i] = cdata[i] >> 8; |
||||
ciphertext[4 * i + 0] = cdata[i] & 0xff; |
||||
} |
||||
|
||||
i = 0; |
||||
encrypted[i++] = '$'; |
||||
encrypted[i++] = BCRYPT_VERSION; |
||||
if (minor) |
||||
encrypted[i++] = minor; |
||||
encrypted[i++] = '$'; |
||||
|
||||
snprintf(encrypted + i, 4, "%2.2u$", logr & 0x001F); |
||||
|
||||
encode_base64((u_int8_t *) encrypted + i + 3, csalt, BCRYPT_MAXSALT); |
||||
encode_base64((u_int8_t *) encrypted + strlen(encrypted), ciphertext, |
||||
4 * BCRYPT_BLOCKS - 1); |
||||
memset(&state, 0, sizeof(state)); |
||||
memset(ciphertext, 0, sizeof(ciphertext)); |
||||
memset(csalt, 0, sizeof(csalt)); |
||||
memset(cdata, 0, sizeof(cdata)); |
||||
} |
||||
|
||||
u_int32_t bcrypt_get_rounds(const char * hash) |
||||
{ |
||||
/* skip past the leading "$" */ |
||||
if (!hash || *(hash++) != '$') return 0; |
||||
|
||||
/* skip past version */ |
||||
if (0 == (*hash++)) return 0; |
||||
if (*hash && *hash != '$') hash++; |
||||
if (*hash++ != '$') return 0; |
||||
|
||||
return atoi(hash); |
||||
} |
||||
|
||||
static void |
||||
encode_base64(u_int8_t *buffer, u_int8_t *data, u_int16_t len) |
||||
{ |
||||
u_int8_t *bp = buffer; |
||||
u_int8_t *p = data; |
||||
u_int8_t c1, c2; |
||||
while (p < data + len) { |
||||
c1 = *p++; |
||||
*bp++ = Base64Code[(c1 >> 2)]; |
||||
c1 = (c1 & 0x03) << 4; |
||||
if (p >= data + len) { |
||||
*bp++ = Base64Code[c1]; |
||||
break; |
||||
} |
||||
c2 = *p++; |
||||
c1 |= (c2 >> 4) & 0x0f; |
||||
*bp++ = Base64Code[c1]; |
||||
c1 = (c2 & 0x0f) << 2; |
||||
if (p >= data + len) { |
||||
*bp++ = Base64Code[c1]; |
||||
break; |
||||
} |
||||
c2 = *p++; |
||||
c1 |= (c2 >> 6) & 0x03; |
||||
*bp++ = Base64Code[c1]; |
||||
*bp++ = Base64Code[c2 & 0x3f]; |
||||
} |
||||
*bp = '\0'; |
||||
} |
@ -0,0 +1,288 @@ |
||||
#define NAPI_VERSION 3 |
||||
|
||||
#include <napi.h> |
||||
|
||||
#include <string> |
||||
#include <cstring> |
||||
#include <vector> |
||||
#include <stdlib.h> // atoi |
||||
|
||||
#include "node_blf.h" |
||||
|
||||
#define NODE_LESS_THAN (!(NODE_VERSION_AT_LEAST(0, 5, 4))) |
||||
|
||||
namespace { |
||||
|
||||
bool ValidateSalt(const char* salt) { |
||||
|
||||
if (!salt || *salt != '$') { |
||||
return false; |
||||
} |
||||
|
||||
// discard $
|
||||
salt++; |
||||
|
||||
if (*salt > BCRYPT_VERSION) { |
||||
return false; |
||||
} |
||||
|
||||
if (salt[1] != '$') { |
||||
switch (salt[1]) { |
||||
case 'a': |
||||
case 'b': |
||||
salt++; |
||||
break; |
||||
default: |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
// discard version + $
|
||||
salt += 2; |
||||
|
||||
if (salt[2] != '$') { |
||||
return false; |
||||
} |
||||
|
||||
int n = atoi(salt); |
||||
if (n > 31 || n < 0) { |
||||
return false; |
||||
} |
||||
|
||||
if (((uint8_t)1 << (uint8_t)n) < BCRYPT_MINROUNDS) { |
||||
return false; |
||||
} |
||||
|
||||
salt += 3; |
||||
if (strlen(salt) * 3 / 4 < BCRYPT_MAXSALT) { |
||||
return false; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
inline char ToCharVersion(const std::string& str) { |
||||
return str[0]; |
||||
} |
||||
|
||||
/* SALT GENERATION */ |
||||
|
||||
class SaltAsyncWorker : public Napi::AsyncWorker { |
||||
public: |
||||
SaltAsyncWorker(const Napi::Function& callback, const std::string& seed, ssize_t rounds, char minor_ver) |
||||
: Napi::AsyncWorker(callback, "bcrypt:SaltAsyncWorker"), seed(seed), rounds(rounds), minor_ver(minor_ver) { |
||||
} |
||||
|
||||
~SaltAsyncWorker() {} |
||||
|
||||
void Execute() { |
||||
bcrypt_gensalt(minor_ver, rounds, (u_int8_t *)&seed[0], salt); |
||||
} |
||||
|
||||
void OnOK() { |
||||
Napi::HandleScope scope(Env()); |
||||
Callback().Call({Env().Undefined(), Napi::String::New(Env(), salt)}); |
||||
} |
||||
|
||||
private: |
||||
std::string seed; |
||||
ssize_t rounds; |
||||
char minor_ver; |
||||
char salt[_SALT_LEN]; |
||||
}; |
||||
|
||||
Napi::Value GenerateSalt(const Napi::CallbackInfo& info) { |
||||
Napi::Env env = info.Env(); |
||||
if (info.Length() < 4) { |
||||
throw Napi::TypeError::New(env, "4 arguments expected"); |
||||
} |
||||
if (!info[0].IsString()) { |
||||
throw Napi::TypeError::New(env, "First argument must be a string"); |
||||
} |
||||
if (!info[2].IsBuffer() || (info[2].As<Napi::Buffer<char>>()).Length() != 16) { |
||||
throw Napi::TypeError::New(env, "Second argument must be a 16 byte Buffer"); |
||||
} |
||||
|
||||
const char minor_ver = ToCharVersion(info[0].As<Napi::String>()); |
||||
const int32_t rounds = info[1].As<Napi::Number>(); |
||||
Napi::Buffer<char> seed = info[2].As<Napi::Buffer<char>>(); |
||||
Napi::Function callback = info[3].As<Napi::Function>(); |
||||
SaltAsyncWorker* saltWorker = new SaltAsyncWorker(callback, std::string(seed.Data(), 16), rounds, minor_ver); |
||||
saltWorker->Queue(); |
||||
return env.Undefined(); |
||||
} |
||||
|
||||
Napi::Value GenerateSaltSync(const Napi::CallbackInfo& info) { |
||||
Napi::Env env = info.Env(); |
||||
if (info.Length() < 3) { |
||||
throw Napi::TypeError::New(env, "3 arguments expected"); |
||||
} |
||||
if (!info[0].IsString()) { |
||||
throw Napi::TypeError::New(env, "First argument must be a string"); |
||||
} |
||||
if (!info[2].IsBuffer() || (info[2].As<Napi::Buffer<char>>()).Length() != 16) { |
||||
throw Napi::TypeError::New(env, "Third argument must be a 16 byte Buffer"); |
||||
} |
||||
const char minor_ver = ToCharVersion(info[0].As<Napi::String>()); |
||||
const int32_t rounds = info[1].As<Napi::Number>(); |
||||
Napi::Buffer<u_int8_t> buffer = info[2].As<Napi::Buffer<u_int8_t>>(); |
||||
u_int8_t* seed = (u_int8_t*) buffer.Data(); |
||||
char salt[_SALT_LEN]; |
||||
bcrypt_gensalt(minor_ver, rounds, seed, salt); |
||||
return Napi::String::New(env, salt, strlen(salt)); |
||||
} |
||||
|
||||
inline std::string BufferToString(const Napi::Buffer<char> &buf) { |
||||
return std::string(buf.Data(), buf.Length()); |
||||
} |
||||
|
||||
/* ENCRYPT DATA - USED TO BE HASHPW */ |
||||
|
||||
class EncryptAsyncWorker : public Napi::AsyncWorker { |
||||
public: |
||||
EncryptAsyncWorker(const Napi::Function& callback, const std::string& input, const std::string& salt) |
||||
: Napi::AsyncWorker(callback, "bcrypt:EncryptAsyncWorker"), input(input), salt(salt) { |
||||
} |
||||
|
||||
~EncryptAsyncWorker() {} |
||||
|
||||
void Execute() { |
||||
if (!(ValidateSalt(salt.c_str()))) { |
||||
SetError("Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue"); |
||||
} |
||||
bcrypt(input.c_str(), input.length(), salt.c_str(), bcrypted); |
||||
} |
||||
|
||||
void OnOK() { |
||||
Napi::HandleScope scope(Env()); |
||||
Callback().Call({Env().Undefined(),Napi::String::New(Env(), bcrypted)}); |
||||
} |
||||
private: |
||||
std::string input; |
||||
std::string salt; |
||||
char bcrypted[_PASSWORD_LEN]; |
||||
}; |
||||
|
||||
Napi::Value Encrypt(const Napi::CallbackInfo& info) { |
||||
if (info.Length() < 3) { |
||||
throw Napi::TypeError::New(info.Env(), "3 arguments expected"); |
||||
} |
||||
std::string data = info[0].IsBuffer() |
||||
? BufferToString(info[0].As<Napi::Buffer<char>>()) |
||||
: info[0].As<Napi::String>(); |
||||
std::string salt = info[1].As<Napi::String>(); |
||||
Napi::Function callback = info[2].As<Napi::Function>(); |
||||
EncryptAsyncWorker* encryptWorker = new EncryptAsyncWorker(callback, data, salt); |
||||
encryptWorker->Queue(); |
||||
return info.Env().Undefined(); |
||||
} |
||||
|
||||
Napi::Value EncryptSync(const Napi::CallbackInfo& info) { |
||||
Napi::Env env = info.Env(); |
||||
if (info.Length() < 2) { |
||||
throw Napi::TypeError::New(info.Env(), "2 arguments expected"); |
||||
} |
||||
std::string data = info[0].IsBuffer() |
||||
? BufferToString(info[0].As<Napi::Buffer<char>>()) |
||||
: info[0].As<Napi::String>(); |
||||
std::string salt = info[1].As<Napi::String>(); |
||||
if (!(ValidateSalt(salt.c_str()))) { |
||||
throw Napi::Error::New(env, "Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue"); |
||||
} |
||||
char bcrypted[_PASSWORD_LEN]; |
||||
bcrypt(data.c_str(), data.length(), salt.c_str(), bcrypted); |
||||
return Napi::String::New(env, bcrypted, strlen(bcrypted)); |
||||
} |
||||
|
||||
/* COMPARATOR */ |
||||
inline bool CompareStrings(const char* s1, const char* s2) { |
||||
return strcmp(s1, s2) == 0; |
||||
} |
||||
|
||||
class CompareAsyncWorker : public Napi::AsyncWorker { |
||||
public: |
||||
CompareAsyncWorker(const Napi::Function& callback, const std::string& input, const std::string& encrypted) |
||||
: Napi::AsyncWorker(callback, "bcrypt:CompareAsyncWorker"), input(input), encrypted(encrypted) { |
||||
result = false; |
||||
} |
||||
|
||||
~CompareAsyncWorker() {} |
||||
|
||||
void Execute() { |
||||
char bcrypted[_PASSWORD_LEN]; |
||||
if (ValidateSalt(encrypted.c_str())) { |
||||
bcrypt(input.c_str(), input.length(), encrypted.c_str(), bcrypted); |
||||
result = CompareStrings(bcrypted, encrypted.c_str()); |
||||
} |
||||
} |
||||
|
||||
void OnOK() { |
||||
Napi::HandleScope scope(Env()); |
||||
Callback().Call({Env().Undefined(), Napi::Boolean::New(Env(), result)}); |
||||
} |
||||
|
||||
private: |
||||
std::string input; |
||||
std::string encrypted; |
||||
bool result; |
||||
}; |
||||
|
||||
Napi::Value Compare(const Napi::CallbackInfo& info) { |
||||
if (info.Length() < 3) { |
||||
throw Napi::TypeError::New(info.Env(), "3 arguments expected"); |
||||
} |
||||
std::string input = info[0].IsBuffer() |
||||
? BufferToString(info[0].As<Napi::Buffer<char>>()) |
||||
: info[0].As<Napi::String>(); |
||||
std::string encrypted = info[1].As<Napi::String>(); |
||||
Napi::Function callback = info[2].As<Napi::Function>(); |
||||
CompareAsyncWorker* compareWorker = new CompareAsyncWorker(callback, input, encrypted); |
||||
compareWorker->Queue(); |
||||
return info.Env().Undefined(); |
||||
} |
||||
|
||||
Napi::Value CompareSync(const Napi::CallbackInfo& info) { |
||||
Napi::Env env = info.Env(); |
||||
if (info.Length() < 2) { |
||||
throw Napi::TypeError::New(info.Env(), "2 arguments expected"); |
||||
} |
||||
std::string pw = info[0].IsBuffer() |
||||
? BufferToString(info[0].As<Napi::Buffer<char>>()) |
||||
: info[0].As<Napi::String>(); |
||||
std::string hash = info[1].As<Napi::String>(); |
||||
char bcrypted[_PASSWORD_LEN]; |
||||
if (ValidateSalt(hash.c_str())) { |
||||
bcrypt(pw.c_str(), pw.length(), hash.c_str(), bcrypted); |
||||
return Napi::Boolean::New(env, CompareStrings(bcrypted, hash.c_str())); |
||||
} else { |
||||
return Napi::Boolean::New(env, false); |
||||
} |
||||
} |
||||
|
||||
Napi::Value GetRounds(const Napi::CallbackInfo& info) { |
||||
Napi::Env env = info.Env(); |
||||
if (info.Length() < 1) { |
||||
throw Napi::TypeError::New(env, "1 argument expected"); |
||||
} |
||||
std::string hash = info[0].As<Napi::String>(); |
||||
u_int32_t rounds; |
||||
if (!(rounds = bcrypt_get_rounds(hash.c_str()))) { |
||||
throw Napi::Error::New(env, "invalid hash provided"); |
||||
} |
||||
return Napi::Number::New(env, rounds); |
||||
} |
||||
|
||||
} // anonymous namespace
|
||||
|
||||
Napi::Object init(Napi::Env env, Napi::Object exports) { |
||||
exports.Set(Napi::String::New(env, "gen_salt_sync"), Napi::Function::New(env, GenerateSaltSync)); |
||||
exports.Set(Napi::String::New(env, "encrypt_sync"), Napi::Function::New(env, EncryptSync)); |
||||
exports.Set(Napi::String::New(env, "compare_sync"), Napi::Function::New(env, CompareSync)); |
||||
exports.Set(Napi::String::New(env, "get_rounds"), Napi::Function::New(env, GetRounds)); |
||||
exports.Set(Napi::String::New(env, "gen_salt"), Napi::Function::New(env, GenerateSalt)); |
||||
exports.Set(Napi::String::New(env, "encrypt"), Napi::Function::New(env, Encrypt)); |
||||
exports.Set(Napi::String::New(env, "compare"), Napi::Function::New(env, Compare)); |
||||
return exports; |
||||
} |
||||
|
||||
NODE_API_MODULE(NODE_GYP_MODULE_NAME, init) |
@ -0,0 +1,679 @@ |
||||
/* $OpenBSD: blowfish.c,v 1.18 2004/11/02 17:23:26 hshoexer Exp $ */ |
||||
/*
|
||||
* Blowfish block cipher for OpenBSD |
||||
* Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> |
||||
* All rights reserved. |
||||
* |
||||
* Implementation advice by David Mazieres <dm@lcs.mit.edu>. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions |
||||
* are met: |
||||
* 1. Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* 2. 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. |
||||
* 3. All advertising materials mentioning features or use of this software |
||||
* must display the following acknowledgement: |
||||
* This product includes software developed by Niels Provos. |
||||
* 4. The name of the author may not be used to endorse or promote products |
||||
* derived from this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. |
||||
*/ |
||||
|
||||
/*
|
||||
* This code is derived from section 14.3 and the given source |
||||
* in section V of Applied Cryptography, second edition. |
||||
* Blowfish is an unpatented fast block cipher designed by |
||||
* Bruce Schneier. |
||||
*/ |
||||
|
||||
#include "node_blf.h" |
||||
|
||||
#undef inline |
||||
#ifdef __GNUC__ |
||||
#define inline __inline |
||||
#else /* !__GNUC__ */ |
||||
#define inline |
||||
#endif /* !__GNUC__ */ |
||||
|
||||
/* Function for Feistel Networks */ |
||||
|
||||
#define F(s, x) ((((s)[ (((x)>>24)&0xFF)] \ |
||||
+ (s)[0x100 + (((x)>>16)&0xFF)]) \
|
||||
^ (s)[0x200 + (((x)>> 8)&0xFF)]) \
|
||||
+ (s)[0x300 + ( (x) &0xFF)]) |
||||
|
||||
#define BLFRND(s,p,i,j,n) (i ^= F(s,j) ^ (p)[n]) |
||||
|
||||
void |
||||
Blowfish_encipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr) |
||||
{ |
||||
u_int32_t Xl; |
||||
u_int32_t Xr; |
||||
u_int32_t *s = c->S[0]; |
||||
u_int32_t *p = c->P; |
||||
|
||||
Xl = *xl; |
||||
Xr = *xr; |
||||
|
||||
Xl ^= p[0]; |
||||
BLFRND(s, p, Xr, Xl, 1); BLFRND(s, p, Xl, Xr, 2); |
||||
BLFRND(s, p, Xr, Xl, 3); BLFRND(s, p, Xl, Xr, 4); |
||||
BLFRND(s, p, Xr, Xl, 5); BLFRND(s, p, Xl, Xr, 6); |
||||
BLFRND(s, p, Xr, Xl, 7); BLFRND(s, p, Xl, Xr, 8); |
||||
BLFRND(s, p, Xr, Xl, 9); BLFRND(s, p, Xl, Xr, 10); |
||||
BLFRND(s, p, Xr, Xl, 11); BLFRND(s, p, Xl, Xr, 12); |
||||
BLFRND(s, p, Xr, Xl, 13); BLFRND(s, p, Xl, Xr, 14); |
||||
BLFRND(s, p, Xr, Xl, 15); BLFRND(s, p, Xl, Xr, 16); |
||||
|
||||
*xl = Xr ^ p[17]; |
||||
*xr = Xl; |
||||
} |
||||
|
||||
void |
||||
Blowfish_decipher(blf_ctx *c, u_int32_t *xl, u_int32_t *xr) |
||||
{ |
||||
u_int32_t Xl; |
||||
u_int32_t Xr; |
||||
u_int32_t *s = c->S[0]; |
||||
u_int32_t *p = c->P; |
||||
|
||||
Xl = *xl; |
||||
Xr = *xr; |
||||
|
||||
Xl ^= p[17]; |
||||
BLFRND(s, p, Xr, Xl, 16); BLFRND(s, p, Xl, Xr, 15); |
||||
BLFRND(s, p, Xr, Xl, 14); BLFRND(s, p, Xl, Xr, 13); |
||||
BLFRND(s, p, Xr, Xl, 12); BLFRND(s, p, Xl, Xr, 11); |
||||
BLFRND(s, p, Xr, Xl, 10); BLFRND(s, p, Xl, Xr, 9); |
||||
BLFRND(s, p, Xr, Xl, 8); BLFRND(s, p, Xl, Xr, 7); |
||||
BLFRND(s, p, Xr, Xl, 6); BLFRND(s, p, Xl, Xr, 5); |
||||
BLFRND(s, p, Xr, Xl, 4); BLFRND(s, p, Xl, Xr, 3); |
||||
BLFRND(s, p, Xr, Xl, 2); BLFRND(s, p, Xl, Xr, 1); |
||||
|
||||
*xl = Xr ^ p[0]; |
||||
*xr = Xl; |
||||
} |
||||
|
||||
void |
||||
Blowfish_initstate(blf_ctx *c) |
||||
{ |
||||
/* P-box and S-box tables initialized with digits of Pi */ |
||||
|
||||
static const blf_ctx initstate = |
||||
{ { |
||||
{ |
||||
0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7, |
||||
0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99, |
||||
0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16, |
||||
0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e, |
||||
0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee, |
||||
0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013, |
||||
0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef, |
||||
0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e, |
||||
0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60, |
||||
0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440, |
||||
0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce, |
||||
0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a, |
||||
0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e, |
||||
0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677, |
||||
0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193, |
||||
0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032, |
||||
0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88, |
||||
0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239, |
||||
0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e, |
||||
0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0, |
||||
0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3, |
||||
0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98, |
||||
0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88, |
||||
0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe, |
||||
0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6, |
||||
0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d, |
||||
0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b, |
||||
0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7, |
||||
0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba, |
||||
0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463, |
||||
0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f, |
||||
0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09, |
||||
0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3, |
||||
0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb, |
||||
0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279, |
||||
0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8, |
||||
0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab, |
||||
0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82, |
||||
0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db, |
||||
0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573, |
||||
0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0, |
||||
0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b, |
||||
0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790, |
||||
0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8, |
||||
0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4, |
||||
0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0, |
||||
0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7, |
||||
0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c, |
||||
0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad, |
||||
0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1, |
||||
0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299, |
||||
0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9, |
||||
0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477, |
||||
0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf, |
||||
0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49, |
||||
0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af, |
||||
0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa, |
||||
0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5, |
||||
0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41, |
||||
0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915, |
||||
0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400, |
||||
0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915, |
||||
0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664, |
||||
0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a}, |
||||
{ |
||||
0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623, |
||||
0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266, |
||||
0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1, |
||||
0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e, |
||||
0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6, |
||||
0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1, |
||||
0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e, |
||||
0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1, |
||||
0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737, |
||||
0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8, |
||||
0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff, |
||||
0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd, |
||||
0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701, |
||||
0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7, |
||||
0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41, |
||||
0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331, |
||||
0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf, |
||||
0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af, |
||||
0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e, |
||||
0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87, |
||||
0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c, |
||||
0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2, |
||||
0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16, |
||||
0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd, |
||||
0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b, |
||||
0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509, |
||||
0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e, |
||||
0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3, |
||||
0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f, |
||||
0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a, |
||||
0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4, |
||||
0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960, |
||||
0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66, |
||||
0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28, |
||||
0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802, |
||||
0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84, |
||||
0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510, |
||||
0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf, |
||||
0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14, |
||||
0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e, |
||||
0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50, |
||||
0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7, |
||||
0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8, |
||||
0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281, |
||||
0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99, |
||||
0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696, |
||||
0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128, |
||||
0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73, |
||||
0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0, |
||||
0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0, |
||||
0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105, |
||||
0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250, |
||||
0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3, |
||||
0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285, |
||||
0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00, |
||||
0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061, |
||||
0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb, |
||||
0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e, |
||||
0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735, |
||||
0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc, |
||||
0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9, |
||||
0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340, |
||||
0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20, |
||||
0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7}, |
||||
{ |
||||
0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934, |
||||
0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068, |
||||
0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af, |
||||
0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840, |
||||
0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45, |
||||
0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504, |
||||
0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a, |
||||
0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb, |
||||
0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee, |
||||
0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6, |
||||
0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42, |
||||
0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b, |
||||
0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2, |
||||
0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb, |
||||
0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527, |
||||
0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b, |
||||
0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33, |
||||
0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c, |
||||
0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3, |
||||
0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc, |
||||
0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17, |
||||
0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564, |
||||
0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b, |
||||
0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115, |
||||
0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922, |
||||
0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728, |
||||
0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0, |
||||
0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e, |
||||
0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37, |
||||
0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d, |
||||
0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804, |
||||
0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b, |
||||
0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3, |
||||
0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb, |
||||
0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d, |
||||
0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c, |
||||
0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350, |
||||
0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9, |
||||
0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a, |
||||
0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe, |
||||
0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d, |
||||
0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc, |
||||
0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f, |
||||
0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61, |
||||
0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2, |
||||
0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9, |
||||
0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2, |
||||
0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c, |
||||
0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e, |
||||
0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633, |
||||
0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10, |
||||
0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169, |
||||
0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52, |
||||
0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027, |
||||
0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5, |
||||
0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62, |
||||
0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634, |
||||
0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76, |
||||
0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24, |
||||
0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc, |
||||
0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4, |
||||
0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c, |
||||
0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837, |
||||
0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0}, |
||||
{ |
||||
0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b, |
||||
0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe, |
||||
0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b, |
||||
0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4, |
||||
0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8, |
||||
0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6, |
||||
0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304, |
||||
0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22, |
||||
0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4, |
||||
0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6, |
||||
0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9, |
||||
0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59, |
||||
0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593, |
||||
0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51, |
||||
0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28, |
||||
0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c, |
||||
0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b, |
||||
0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28, |
||||
0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c, |
||||
0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd, |
||||
0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a, |
||||
0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319, |
||||
0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb, |
||||
0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f, |
||||
0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991, |
||||
0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32, |
||||
0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680, |
||||
0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166, |
||||
0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae, |
||||
0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb, |
||||
0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5, |
||||
0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47, |
||||
0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370, |
||||
0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d, |
||||
0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84, |
||||
0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048, |
||||
0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8, |
||||
0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd, |
||||
0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9, |
||||
0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7, |
||||
0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38, |
||||
0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f, |
||||
0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c, |
||||
0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525, |
||||
0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1, |
||||
0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442, |
||||
0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964, |
||||
0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e, |
||||
0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8, |
||||
0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d, |
||||
0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f, |
||||
0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299, |
||||
0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02, |
||||
0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc, |
||||
0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614, |
||||
0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a, |
||||
0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6, |
||||
0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b, |
||||
0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0, |
||||
0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060, |
||||
0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e, |
||||
0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9, |
||||
0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f, |
||||
0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6} |
||||
}, |
||||
{ |
||||
0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, |
||||
0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89, |
||||
0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c, |
||||
0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, |
||||
0x9216d5d9, 0x8979fb1b |
||||
} }; |
||||
|
||||
*c = initstate; |
||||
} |
||||
|
||||
u_int32_t |
||||
Blowfish_stream2word(const u_int8_t *data, u_int16_t databytes, |
||||
u_int16_t *current) |
||||
{ |
||||
u_int8_t i; |
||||
u_int16_t j; |
||||
u_int32_t temp; |
||||
|
||||
temp = 0x00000000; |
||||
j = *current; |
||||
|
||||
for (i = 0; i < 4; i++, j++) { |
||||
if (j >= databytes) |
||||
j = 0; |
||||
temp = (temp << 8) | data[j]; |
||||
} |
||||
|
||||
*current = j; |
||||
return temp; |
||||
} |
||||
|
||||
void |
||||
Blowfish_expand0state(blf_ctx *c, const u_int8_t *key, u_int16_t keybytes) |
||||
{ |
||||
u_int16_t i; |
||||
u_int16_t j; |
||||
u_int16_t k; |
||||
u_int32_t temp; |
||||
u_int32_t datal; |
||||
u_int32_t datar; |
||||
|
||||
j = 0; |
||||
for (i = 0; i < BLF_N + 2; i++) { |
||||
/* Extract 4 int8 to 1 int32 from keystream */ |
||||
temp = Blowfish_stream2word(key, keybytes, &j); |
||||
c->P[i] = c->P[i] ^ temp; |
||||
} |
||||
|
||||
j = 0; |
||||
datal = 0x00000000; |
||||
datar = 0x00000000; |
||||
for (i = 0; i < BLF_N + 2; i += 2) { |
||||
Blowfish_encipher(c, &datal, &datar); |
||||
|
||||
c->P[i] = datal; |
||||
c->P[i + 1] = datar; |
||||
} |
||||
|
||||
for (i = 0; i < 4; i++) { |
||||
for (k = 0; k < 256; k += 2) { |
||||
Blowfish_encipher(c, &datal, &datar); |
||||
|
||||
c->S[i][k] = datal; |
||||
c->S[i][k + 1] = datar; |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
void |
||||
Blowfish_expandstate(blf_ctx *c, const u_int8_t *data, u_int16_t databytes, |
||||
const u_int8_t *key, u_int16_t keybytes) |
||||
{ |
||||
u_int16_t i; |
||||
u_int16_t j; |
||||
u_int16_t k; |
||||
u_int32_t temp; |
||||
u_int32_t datal; |
||||
u_int32_t datar; |
||||
|
||||
j = 0; |
||||
for (i = 0; i < BLF_N + 2; i++) { |
||||
/* Extract 4 int8 to 1 int32 from keystream */ |
||||
temp = Blowfish_stream2word(key, keybytes, &j); |
||||
c->P[i] = c->P[i] ^ temp; |
||||
} |
||||
|
||||
j = 0; |
||||
datal = 0x00000000; |
||||
datar = 0x00000000; |
||||
for (i = 0; i < BLF_N + 2; i += 2) { |
||||
datal ^= Blowfish_stream2word(data, databytes, &j); |
||||
datar ^= Blowfish_stream2word(data, databytes, &j); |
||||
Blowfish_encipher(c, &datal, &datar); |
||||
|
||||
c->P[i] = datal; |
||||
c->P[i + 1] = datar; |
||||
} |
||||
|
||||
for (i = 0; i < 4; i++) { |
||||
for (k = 0; k < 256; k += 2) { |
||||
datal ^= Blowfish_stream2word(data, databytes, &j); |
||||
datar ^= Blowfish_stream2word(data, databytes, &j); |
||||
Blowfish_encipher(c, &datal, &datar); |
||||
|
||||
c->S[i][k] = datal; |
||||
c->S[i][k + 1] = datar; |
||||
} |
||||
} |
||||
|
||||
} |
||||
|
||||
void |
||||
blf_key(blf_ctx *c, const u_int8_t *k, u_int16_t len) |
||||
{ |
||||
/* Initialize S-boxes and subkeys with Pi */ |
||||
Blowfish_initstate(c); |
||||
|
||||
/* Transform S-boxes and subkeys with key */ |
||||
Blowfish_expand0state(c, k, len); |
||||
} |
||||
|
||||
void |
||||
blf_enc(blf_ctx *c, u_int32_t *data, u_int16_t blocks) |
||||
{ |
||||
u_int32_t *d; |
||||
u_int16_t i; |
||||
|
||||
d = data; |
||||
for (i = 0; i < blocks; i++) { |
||||
Blowfish_encipher(c, d, d + 1); |
||||
d += 2; |
||||
} |
||||
} |
||||
|
||||
void |
||||
blf_dec(blf_ctx *c, u_int32_t *data, u_int16_t blocks) |
||||
{ |
||||
u_int32_t *d; |
||||
u_int16_t i; |
||||
|
||||
d = data; |
||||
for (i = 0; i < blocks; i++) { |
||||
Blowfish_decipher(c, d, d + 1); |
||||
d += 2; |
||||
} |
||||
} |
||||
|
||||
void |
||||
blf_ecb_encrypt(blf_ctx *c, u_int8_t *data, u_int32_t len) |
||||
{ |
||||
u_int32_t l, r; |
||||
u_int32_t i; |
||||
|
||||
for (i = 0; i < len; i += 8) { |
||||
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; |
||||
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; |
||||
Blowfish_encipher(c, &l, &r); |
||||
data[0] = l >> 24 & 0xff; |
||||
data[1] = l >> 16 & 0xff; |
||||
data[2] = l >> 8 & 0xff; |
||||
data[3] = l & 0xff; |
||||
data[4] = r >> 24 & 0xff; |
||||
data[5] = r >> 16 & 0xff; |
||||
data[6] = r >> 8 & 0xff; |
||||
data[7] = r & 0xff; |
||||
data += 8; |
||||
} |
||||
} |
||||
|
||||
void |
||||
blf_ecb_decrypt(blf_ctx *c, u_int8_t *data, u_int32_t len) |
||||
{ |
||||
u_int32_t l, r; |
||||
u_int32_t i; |
||||
|
||||
for (i = 0; i < len; i += 8) { |
||||
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; |
||||
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; |
||||
Blowfish_decipher(c, &l, &r); |
||||
data[0] = l >> 24 & 0xff; |
||||
data[1] = l >> 16 & 0xff; |
||||
data[2] = l >> 8 & 0xff; |
||||
data[3] = l & 0xff; |
||||
data[4] = r >> 24 & 0xff; |
||||
data[5] = r >> 16 & 0xff; |
||||
data[6] = r >> 8 & 0xff; |
||||
data[7] = r & 0xff; |
||||
data += 8; |
||||
} |
||||
} |
||||
|
||||
void |
||||
blf_cbc_encrypt(blf_ctx *c, u_int8_t *iv, u_int8_t *data, u_int32_t len) |
||||
{ |
||||
u_int32_t l, r; |
||||
u_int32_t i, j; |
||||
|
||||
for (i = 0; i < len; i += 8) { |
||||
for (j = 0; j < 8; j++) |
||||
data[j] ^= iv[j]; |
||||
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; |
||||
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; |
||||
Blowfish_encipher(c, &l, &r); |
||||
data[0] = l >> 24 & 0xff; |
||||
data[1] = l >> 16 & 0xff; |
||||
data[2] = l >> 8 & 0xff; |
||||
data[3] = l & 0xff; |
||||
data[4] = r >> 24 & 0xff; |
||||
data[5] = r >> 16 & 0xff; |
||||
data[6] = r >> 8 & 0xff; |
||||
data[7] = r & 0xff; |
||||
iv = data; |
||||
data += 8; |
||||
} |
||||
} |
||||
|
||||
void |
||||
blf_cbc_decrypt(blf_ctx *c, u_int8_t *iva, u_int8_t *data, u_int32_t len) |
||||
{ |
||||
u_int32_t l, r; |
||||
u_int8_t *iv; |
||||
u_int32_t i, j; |
||||
|
||||
iv = data + len - 16; |
||||
data = data + len - 8; |
||||
for (i = len - 8; i >= 8; i -= 8) { |
||||
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; |
||||
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; |
||||
Blowfish_decipher(c, &l, &r); |
||||
data[0] = l >> 24 & 0xff; |
||||
data[1] = l >> 16 & 0xff; |
||||
data[2] = l >> 8 & 0xff; |
||||
data[3] = l & 0xff; |
||||
data[4] = r >> 24 & 0xff; |
||||
data[5] = r >> 16 & 0xff; |
||||
data[6] = r >> 8 & 0xff; |
||||
data[7] = r & 0xff; |
||||
for (j = 0; j < 8; j++) |
||||
data[j] ^= iv[j]; |
||||
iv -= 8; |
||||
data -= 8; |
||||
} |
||||
l = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3]; |
||||
r = data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]; |
||||
Blowfish_decipher(c, &l, &r); |
||||
data[0] = l >> 24 & 0xff; |
||||
data[1] = l >> 16 & 0xff; |
||||
data[2] = l >> 8 & 0xff; |
||||
data[3] = l & 0xff; |
||||
data[4] = r >> 24 & 0xff; |
||||
data[5] = r >> 16 & 0xff; |
||||
data[6] = r >> 8 & 0xff; |
||||
data[7] = r & 0xff; |
||||
for (j = 0; j < 8; j++) |
||||
data[j] ^= iva[j]; |
||||
} |
||||
|
||||
#if 0 |
||||
void |
||||
report(u_int32_t data[], u_int16_t len) |
||||
{ |
||||
u_int16_t i; |
||||
for (i = 0; i < len; i += 2) |
||||
printf("Block %0hd: %08lx %08lx.\n", |
||||
i / 2, data[i], data[i + 1]); |
||||
} |
||||
void |
||||
main(void) |
||||
{ |
||||
|
||||
blf_ctx c; |
||||
char key[] = "AAAAA"; |
||||
char key2[] = "abcdefghijklmnopqrstuvwxyz"; |
||||
|
||||
u_int32_t data[10]; |
||||
u_int32_t data2[] = |
||||
{0x424c4f57l, 0x46495348l}; |
||||
|
||||
u_int16_t i; |
||||
|
||||
/* First test */ |
||||
for (i = 0; i < 10; i++) |
||||
data[i] = i; |
||||
|
||||
blf_key(&c, (u_int8_t *) key, 5); |
||||
blf_enc(&c, data, 5); |
||||
blf_dec(&c, data, 1); |
||||
blf_dec(&c, data + 2, 4); |
||||
printf("Should read as 0 - 9.\n"); |
||||
report(data, 10); |
||||
|
||||
/* Second test */ |
||||
blf_key(&c, (u_int8_t *) key2, strlen(key2)); |
||||
blf_enc(&c, data2, 1); |
||||
printf("\nShould read as: 0x324ed0fe 0xf413a203.\n"); |
||||
report(data2, 2); |
||||
blf_dec(&c, data2, 1); |
||||
report(data2, 2); |
||||
} |
||||
#endif |
@ -0,0 +1,132 @@ |
||||
/* $OpenBSD: blf.h,v 1.7 2007/03/14 17:59:41 grunk Exp $ */ |
||||
/*
|
||||
* Blowfish - a fast block cipher designed by Bruce Schneier |
||||
* |
||||
* Copyright 1997 Niels Provos <provos@physnet.uni-hamburg.de> |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions |
||||
* are met: |
||||
* 1. Redistributions of source code must retain the above copyright |
||||
* notice, this list of conditions and the following disclaimer. |
||||
* 2. 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. |
||||
* 3. All advertising materials mentioning features or use of this software |
||||
* must display the following acknowledgement: |
||||
* This product includes software developed by Niels Provos. |
||||
* 4. The name of the author may not be used to endorse or promote products |
||||
* derived from this software without specific prior written permission. |
||||
* |
||||
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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. |
||||
*/ |
||||
|
||||
#ifndef _NODE_BLF_H_ |
||||
#define _NODE_BLF_H_ |
||||
|
||||
#include <sys/types.h> |
||||
|
||||
/* Solaris compatibility */ |
||||
#ifdef __sun |
||||
#define u_int8_t uint8_t |
||||
#define u_int16_t uint16_t |
||||
#define u_int32_t uint32_t |
||||
#define u_int64_t uint64_t |
||||
#endif |
||||
|
||||
#ifdef _WIN32 |
||||
#define u_int8_t unsigned __int8 |
||||
#define u_int16_t unsigned __int16 |
||||
#define u_int32_t unsigned __int32 |
||||
#define u_int64_t unsigned __int64 |
||||
#endif |
||||
|
||||
/* Windows ssize_t compatibility */ |
||||
#if defined(_WIN32) || defined(_WIN64) |
||||
# if defined(_WIN64) |
||||
typedef __int64 LONG_PTR; |
||||
# else |
||||
typedef long LONG_PTR; |
||||
# endif |
||||
typedef LONG_PTR SSIZE_T; |
||||
typedef SSIZE_T ssize_t; |
||||
#endif |
||||
|
||||
/* z/OS compatibility */ |
||||
#ifdef __MVS__ |
||||
typedef unsigned char u_int8_t; |
||||
typedef unsigned short u_int16_t; |
||||
typedef unsigned int u_int32_t; |
||||
typedef unsigned long long u_int64_t; |
||||
#endif |
||||
|
||||
#define BCRYPT_VERSION '2' |
||||
#define BCRYPT_MAXSALT 16 /* Precomputation is just so nice */ |
||||
#define BCRYPT_BLOCKS 6 /* Ciphertext blocks */ |
||||
#define BCRYPT_MINROUNDS 16 /* we have log2(rounds) in salt */ |
||||
|
||||
/* Schneier specifies a maximum key length of 56 bytes.
|
||||
* This ensures that every key bit affects every cipher |
||||
* bit. However, the subkeys can hold up to 72 bytes. |
||||
* Warning: For normal blowfish encryption only 56 bytes |
||||
* of the key affect all cipherbits. |
||||
*/ |
||||
|
||||
#define BLF_N 16 /* Number of Subkeys */ |
||||
#define BLF_MAXKEYLEN ((BLF_N-2)*4) /* 448 bits */ |
||||
#define BLF_MAXUTILIZED ((BLF_N+2)*4) /* 576 bits */ |
||||
|
||||
#define _PASSWORD_LEN 128 /* max length, not counting NUL */ |
||||
#define _SALT_LEN 32 /* max length */ |
||||
|
||||
/* Blowfish context */ |
||||
typedef struct BlowfishContext { |
||||
u_int32_t S[4][256]; /* S-Boxes */ |
||||
u_int32_t P[BLF_N + 2]; /* Subkeys */ |
||||
} blf_ctx; |
||||
|
||||
/* Raw access to customized Blowfish
|
||||
* blf_key is just: |
||||
* Blowfish_initstate( state ) |
||||
* Blowfish_expand0state( state, key, keylen ) |
||||
*/ |
||||
|
||||
void Blowfish_encipher(blf_ctx *, u_int32_t *, u_int32_t *); |
||||
void Blowfish_decipher(blf_ctx *, u_int32_t *, u_int32_t *); |
||||
void Blowfish_initstate(blf_ctx *); |
||||
void Blowfish_expand0state(blf_ctx *, const u_int8_t *, u_int16_t); |
||||
void Blowfish_expandstate |
||||
(blf_ctx *, const u_int8_t *, u_int16_t, const u_int8_t *, u_int16_t); |
||||
|
||||
/* Standard Blowfish */ |
||||
|
||||
void blf_key(blf_ctx *, const u_int8_t *, u_int16_t); |
||||
void blf_enc(blf_ctx *, u_int32_t *, u_int16_t); |
||||
void blf_dec(blf_ctx *, u_int32_t *, u_int16_t); |
||||
|
||||
void blf_ecb_encrypt(blf_ctx *, u_int8_t *, u_int32_t); |
||||
void blf_ecb_decrypt(blf_ctx *, u_int8_t *, u_int32_t); |
||||
|
||||
void blf_cbc_encrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t); |
||||
void blf_cbc_decrypt(blf_ctx *, u_int8_t *, u_int8_t *, u_int32_t); |
||||
|
||||
/* Converts u_int8_t to u_int32_t */ |
||||
u_int32_t Blowfish_stream2word(const u_int8_t *, u_int16_t , u_int16_t *); |
||||
|
||||
/* bcrypt functions*/ |
||||
void bcrypt_gensalt(char, u_int8_t, u_int8_t*, char *); |
||||
void bcrypt(const char *, size_t key_len, const char *, char *); |
||||
void encode_salt(char *, u_int8_t *, char, u_int16_t, u_int8_t); |
||||
u_int32_t bcrypt_get_rounds(const char *); |
||||
|
||||
#endif |
@ -0,0 +1,209 @@ |
||||
const bcrypt = require('../bcrypt'); |
||||
|
||||
test('salt_length', done => { |
||||
expect.assertions(1); |
||||
bcrypt.genSalt(10, function (err, salt) { |
||||
expect(salt).toHaveLength(29); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('salt_only_cb', () => { |
||||
expect.assertions(1); |
||||
expect(() => { |
||||
bcrypt.genSalt((err, salt) => { |
||||
}); |
||||
}).not.toThrow(); |
||||
}) |
||||
|
||||
test('salt_rounds_is_string_number', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt('10', void 0, function (err, salt) { |
||||
expect(err instanceof Error).toBe(true) |
||||
expect(err.message).toBe('rounds must be a number') |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('salt_rounds_is_string_non_number', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt('z', function (err, salt) { |
||||
expect(err instanceof Error).toBe(true) |
||||
expect(err.message).toBe('rounds must be a number') |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('salt_minor', done => { |
||||
expect.assertions(3); |
||||
bcrypt.genSalt(10, 'a', function (err, value) { |
||||
expect(value).toHaveLength(29); |
||||
const [_, minor, salt] = value.split('$'); |
||||
expect(minor).toEqual('2a'); |
||||
expect(salt).toEqual('10'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('salt_minor_b', done => { |
||||
expect.assertions(3); |
||||
bcrypt.genSalt(10, 'b', function (err, value) { |
||||
expect(value).toHaveLength(29); |
||||
const [_, minor, salt] = value.split('$'); |
||||
expect(minor).toEqual('2b'); |
||||
expect(salt).toEqual('10'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt(10, function (err, salt) { |
||||
bcrypt.hash('password', salt, function (err, res) { |
||||
expect(res).toBeDefined(); |
||||
expect(err).toBeUndefined(); |
||||
done(); |
||||
}); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_rounds', done => { |
||||
expect.assertions(1); |
||||
bcrypt.hash('bacon', 8, function (err, hash) { |
||||
expect(bcrypt.getRounds(hash)).toEqual(8); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_empty_strings', done => { |
||||
expect.assertions(1); |
||||
bcrypt.genSalt(10, function (err, salt) { |
||||
bcrypt.hash('', salt, function (err, res) { |
||||
expect(res).toBeDefined(); |
||||
done(); |
||||
}); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_fails_with_empty_salt', done => { |
||||
expect.assertions(1); |
||||
bcrypt.hash('', '', function (err, res) { |
||||
expect(err.message).toBe('Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue') |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_no_params', done => { |
||||
expect.assertions(1); |
||||
bcrypt.hash(function (err, hash) { |
||||
expect(err.message).toBe('data must be a string or Buffer and salt must either be a salt string or a number of rounds') |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_one_param', done => { |
||||
expect.assertions(1); |
||||
bcrypt.hash('password', function (err, hash) { |
||||
expect(err.message).toBe('data must be a string or Buffer and salt must either be a salt string or a number of rounds'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_salt_validity', done => { |
||||
expect.assertions(2); |
||||
bcrypt.hash('password', '$2a$10$somesaltyvaluertsetrse', function (err, enc) { |
||||
expect(err).toBeUndefined(); |
||||
bcrypt.hash('password', 'some$value', function (err, enc) { |
||||
expect(err.message).toBe("Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue"); |
||||
done(); |
||||
}); |
||||
}); |
||||
}) |
||||
|
||||
test('verify_salt', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt(10, function (err, value) { |
||||
const [_, version, rounds] = value.split('$'); |
||||
expect(version).toEqual('2b'); |
||||
expect(rounds).toEqual('10'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('verify_salt_min_rounds', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt(1, function (err, value) { |
||||
const [_, version, rounds] = value.split('$'); |
||||
expect(version).toEqual('2b'); |
||||
expect(rounds).toEqual('04'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('verify_salt_max_rounds', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt(100, function (err, value) { |
||||
const [_, version, rounds] = value.split('$'); |
||||
expect(version).toEqual('2b'); |
||||
expect(rounds).toEqual('31'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_compare', done => { |
||||
expect.assertions(2); |
||||
bcrypt.genSalt(10, function (err, salt) { |
||||
bcrypt.hash("test", salt, function (err, hash) { |
||||
bcrypt.compare("test", hash, function (err, res) { |
||||
expect(hash).toBeDefined(); |
||||
bcrypt.compare("blah", hash, function (err, res) { |
||||
expect(res).toBe(false); |
||||
done(); |
||||
}); |
||||
}); |
||||
}); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_compare_empty_strings', done => { |
||||
expect.assertions(2); |
||||
const hash = bcrypt.hashSync("test", bcrypt.genSaltSync(10)); |
||||
|
||||
bcrypt.compare("", hash, function (err, res) { |
||||
expect(res).toEqual(false) |
||||
bcrypt.compare("", "", function (err, res) { |
||||
expect(res).toEqual(false); |
||||
done(); |
||||
}); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_compare_invalid_strings', done => { |
||||
expect.assertions(2); |
||||
const fullString = 'envy1362987212538'; |
||||
const hash = '$2a$10$XOPbrlUPQdwdJUpSrIF6X.LbE14qsMmKGhM1A8W9iqaG3vv1BD7WC'; |
||||
const wut = ':'; |
||||
bcrypt.compare(fullString, hash, function (err, res) { |
||||
expect(res).toBe(true); |
||||
bcrypt.compare(fullString, wut, function (err, res) { |
||||
expect(res).toBe(false); |
||||
done(); |
||||
}); |
||||
}); |
||||
}) |
||||
|
||||
test('compare_no_params', done => { |
||||
expect.assertions(1); |
||||
bcrypt.compare(function (err, hash) { |
||||
expect(err.message).toBe('data and hash arguments required'); |
||||
done(); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_compare_one_param', done => { |
||||
expect.assertions(1); |
||||
bcrypt.compare('password', function (err, hash) { |
||||
expect(err.message).toBe('data and hash arguments required'); |
||||
done(); |
||||
}); |
||||
}) |
@ -0,0 +1,48 @@ |
||||
const bcrypt = require('../bcrypt'); |
||||
|
||||
// some tests were adapted from https://github.com/riverrun/bcrypt_elixir/blob/master/test/base_test.exs
|
||||
// which are under the BSD LICENSE
|
||||
|
||||
test('openwall', () => { |
||||
expect(bcrypt.hashSync("U*U", "$2a$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW"); |
||||
expect(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK"); |
||||
expect(bcrypt.hashSync("U*U*U", "$2a$05$XXXXXXXXXXXXXXXXXXXXXO")).toStrictEqual("$2a$05$XXXXXXXXXXXXXXXXXXXXXOAcXxm9kjPGEMsLznoKqmqw7tc8WCx4a"); |
||||
expect(bcrypt.hashSync("", "$2a$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.7uG0VCzI2bS7j6ymqJi9CdcdxiRTWNy"); |
||||
expect(bcrypt.hashSync("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", "$2a$05$abcdefghijklmnopqrstuu")).toStrictEqual("$2a$05$abcdefghijklmnopqrstuu5s2v8.iXieOjg/.AySBTTZIIVFJeBui"); |
||||
}) |
||||
|
||||
test('openbsd', () => { |
||||
expect(bcrypt.hashSync("000000000000000000000000000000000000000000000000000000000000000000000000", "$2a$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS") |
||||
expect(bcrypt.hashSync("000000000000000000000000000000000000000000000000000000000000000000000000", "$2b$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2b$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS") |
||||
}) |
||||
|
||||
test('long_passwords', () => { |
||||
// bcrypt wrap-around bug in $2a$
|
||||
expect(bcrypt.hashSync("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234", "$2a$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS") |
||||
expect(bcrypt.hashSync("01XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "$2a$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.6.O1dLNbjod2uo0DVcW.jHucKbPDdHS") |
||||
|
||||
// tests for $2b$ which fixes wrap-around bugs
|
||||
expect(bcrypt.hashSync("012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234", "$2b$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2b$05$CCCCCCCCCCCCCCCCCCCCC.XxrQqgBi/5Sxuq9soXzDtjIZ7w5pMfK") |
||||
expect(bcrypt.hashSync("0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345", "$2b$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2b$05$CCCCCCCCCCCCCCCCCCCCC.XxrQqgBi/5Sxuq9soXzDtjIZ7w5pMfK") |
||||
}) |
||||
|
||||
test('embedded_nulls', () => { |
||||
expect(bcrypt.hashSync("Passw\0rd123", "$2b$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2b$05$CCCCCCCCCCCCCCCCCCCCC.VHy/kzL4sCcX3Ib3wN5rNGiRt.TpfxS") |
||||
expect(bcrypt.hashSync("Passw\0 you can literally write anything after the NUL character", "$2b$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2b$05$CCCCCCCCCCCCCCCCCCCCC.4vJLJQ6nZ/70INTjjSZWQ0iyUek92tu") |
||||
expect(bcrypt.hashSync(Buffer.from("Passw\0 you can literally write anything after the NUL character"), "$2b$05$CCCCCCCCCCCCCCCCCCCCC.")).toStrictEqual("$2b$05$CCCCCCCCCCCCCCCCCCCCC.4vJLJQ6nZ/70INTjjSZWQ0iyUek92tu") |
||||
}) |
||||
|
||||
test('shorten_salt_to_128_bits', () => { |
||||
expect(bcrypt.hashSync("test", "$2a$10$1234567899123456789012")).toStrictEqual("$2a$10$123456789912345678901u.OtL1A1eGK5wmvBKUDYKvuVKI7h2XBu") |
||||
expect(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCCh")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCCeUQ7VjYZ2hd4bLYZdhuPpZMUpEUJDw1S") |
||||
expect(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCCM")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK") |
||||
expect(bcrypt.hashSync("U*U*", "$2a$05$CCCCCCCCCCCCCCCCCCCCCA")).toStrictEqual("$2a$05$CCCCCCCCCCCCCCCCCCCCC.VGOzA784oUp/Z0DY336zx7pLYAy0lwK") |
||||
}) |
||||
|
||||
test('consistency', () => { |
||||
expect(bcrypt.hashSync("ππππππππ", "$2a$10$.TtQJ4Jr6isd4Hp.mVfZeu")).toStrictEqual("$2a$10$.TtQJ4Jr6isd4Hp.mVfZeuh6Gws4rOQ/vdBczhDx.19NFK0Y84Dle") |
||||
expect(bcrypt.hashSync("p@5sw0rd", "$2b$12$zQ4CooEXdGqcwi0PHsgc8e")).toStrictEqual("$2b$12$zQ4CooEXdGqcwi0PHsgc8eAf0DLXE/XHoBE8kCSGQ97rXwuClaPam") |
||||
expect(bcrypt.hashSync("C'est bon, la vie!", "$2b$12$cbo7LZ.wxgW4yxAA5Vqlv.")).toStrictEqual("$2b$12$cbo7LZ.wxgW4yxAA5Vqlv.KR6QFPt4qCdc9RYJNXxa/rbUOp.1sw.") |
||||
expect(bcrypt.hashSync("ἓν οἶδα ὅτι οὐδὲν οἶδα", "$2b$12$LeHKWR2bmrazi/6P22Jpau")).toStrictEqual("$2b$12$LeHKWR2bmrazi/6P22JpauX5my/eKwwKpWqL7L5iEByBnxNc76FRW") |
||||
expect(bcrypt.hashSync(Buffer.from("ἓν οἶδα ὅτι οὐδὲν οἶδα"), "$2b$12$LeHKWR2bmrazi/6P22Jpau")).toStrictEqual("$2b$12$LeHKWR2bmrazi/6P22JpauX5my/eKwwKpWqL7L5iEByBnxNc76FRW") |
||||
}) |
@ -0,0 +1,168 @@ |
||||
const bcrypt = require('../bcrypt'); |
||||
const promises = require('../promises'); |
||||
|
||||
test('salt_returns_promise_on_no_args', () => { |
||||
// make sure test passes with non-native implementations such as bluebird
|
||||
// http://stackoverflow.com/questions/27746304/how-do-i-tell-if-an-object-is-a-promise
|
||||
expect(typeof bcrypt.genSalt().then).toEqual('function') |
||||
}) |
||||
|
||||
test('salt_returns_promise_on_null_callback', () => { |
||||
expect(typeof bcrypt.genSalt(13, null, null).then).toEqual('function') |
||||
}) |
||||
|
||||
test('salt_length', () => { |
||||
return expect(bcrypt.genSalt(10)).resolves.toHaveLength(29); |
||||
}) |
||||
|
||||
test('salt_rounds_is_string_number', () => { |
||||
return expect(bcrypt.genSalt('10')).rejects.toThrow('rounds must be a number'); |
||||
}) |
||||
|
||||
test('salt_rounds_is_string_non_number', () => { |
||||
return expect(bcrypt.genSalt('b')).rejects.toThrow('rounds must be a number'); |
||||
}) |
||||
|
||||
test('hash_returns_promise_on_null_callback', () => { |
||||
expect(typeof bcrypt.hash('password', 10, null).then).toStrictEqual('function') |
||||
}) |
||||
|
||||
test('hash', () => { |
||||
return expect(bcrypt.genSalt(10) |
||||
.then(salt => bcrypt.hash('password', salt))).resolves.toBeDefined() |
||||
}) |
||||
|
||||
test('hash_rounds', () => { |
||||
return bcrypt.hash('bacon', 8).then(hash => { |
||||
expect(bcrypt.getRounds(hash)).toStrictEqual(8) |
||||
}); |
||||
}) |
||||
|
||||
test('hash_empty_strings', () => { |
||||
expect.assertions(2); |
||||
return Promise.all([ |
||||
expect(bcrypt.genSalt(10) |
||||
.then(salt => bcrypt.hash('', salt))) |
||||
.resolves.toBeDefined(), |
||||
expect(bcrypt.hash('', '')).rejects.toThrow(''), |
||||
]); |
||||
}) |
||||
|
||||
test('hash_no_params', () => { |
||||
expect.assertions(1); |
||||
return expect(bcrypt.hash()).rejects.toThrow('data and salt arguments required'); |
||||
}) |
||||
|
||||
test('hash_one_param', () => { |
||||
return expect(bcrypt.hash('password')).rejects.toThrow('data and salt arguments required'); |
||||
}) |
||||
|
||||
test('hash_salt_validity', () => { |
||||
expect.assertions(2); |
||||
return Promise.all( |
||||
[ |
||||
expect(bcrypt.hash('password', '$2a$10$somesaltyvaluertsetrse')).resolves.toBeDefined(), |
||||
expect(bcrypt.hash('password', 'some$value')).rejects.toThrow("Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue") |
||||
]); |
||||
}) |
||||
|
||||
test('verify_salt', () => { |
||||
expect.assertions(2); |
||||
return bcrypt.genSalt(10).then(result => { |
||||
const [_, version, salt] = result.split('$'); |
||||
expect(version).toEqual('2b') |
||||
expect(salt).toEqual('10') |
||||
}); |
||||
}) |
||||
|
||||
test('verify_salt_min_rounds', () => { |
||||
expect.assertions(2); |
||||
return bcrypt.genSalt(1).then(value => { |
||||
const [_, version, rounds] = value.split('$'); |
||||
expect(version).toEqual('2b'); |
||||
expect(rounds).toEqual('04'); |
||||
}); |
||||
}) |
||||
|
||||
test('verify_salt_max_rounds', () => { |
||||
expect.assertions(2); |
||||
return bcrypt.genSalt(100).then(value => { |
||||
const [_, version, rounds] = value.split('$'); |
||||
expect(version).toEqual('2b'); |
||||
expect(rounds).toEqual('31'); |
||||
}); |
||||
}) |
||||
|
||||
test('hash_compare_returns_promise_on_null_callback', () => { |
||||
expect(typeof bcrypt.compare('password', 'something', null).then).toStrictEqual('function') |
||||
}) |
||||
|
||||
test('hash_compare', () => { |
||||
expect.assertions(3); |
||||
return bcrypt.genSalt(10).then(function (salt) { |
||||
expect(salt).toHaveLength(29); |
||||
return bcrypt.hash("test", salt); |
||||
}).then(hash => Promise.all( |
||||
[ |
||||
expect(bcrypt.compare("test", hash)).resolves.toEqual(true), |
||||
expect(bcrypt.compare("blah", hash)).resolves.toEqual(false) |
||||
])); |
||||
}) |
||||
|
||||
test('hash_compare_empty_strings', () => { |
||||
expect.assertions(2); |
||||
const hash = bcrypt.hashSync("test", bcrypt.genSaltSync(10)); |
||||
return Promise.all([ |
||||
expect(bcrypt.compare("", hash)).resolves.toEqual(false), |
||||
expect(bcrypt.compare("", "")).resolves.toEqual(false) |
||||
]); |
||||
}) |
||||
|
||||
test('hash_compare_invalid_strings', () => { |
||||
const fullString = 'envy1362987212538'; |
||||
const hash = '$2a$10$XOPbrlUPQdwdJUpSrIF6X.LbE14qsMmKGhM1A8W9iqaG3vv1BD7WC'; |
||||
const wut = ':'; |
||||
return Promise.all([ |
||||
expect(bcrypt.compare(fullString, hash)).resolves.toEqual(true), |
||||
expect(bcrypt.compare(fullString, wut)).resolves.toEqual(false), |
||||
]); |
||||
}) |
||||
|
||||
test('hash_compare_no_params', () => { |
||||
expect.assertions(1); |
||||
return expect(bcrypt.compare()).rejects.toThrow('data and hash arguments required') |
||||
}) |
||||
|
||||
test('hash_compare_one_param', () => { |
||||
expect.assertions(1); |
||||
return expect(bcrypt.compare('password')).rejects.toThrow('data and hash arguments required') |
||||
}) |
||||
|
||||
test('change_promise_impl_reject', () => { |
||||
|
||||
promises.use({ |
||||
reject: function () { |
||||
return 'mock'; |
||||
} |
||||
}); |
||||
|
||||
expect(promises.reject()).toEqual('mock'); |
||||
|
||||
// need to reset the promise implementation because of require cache
|
||||
promises.use(global.Promise); |
||||
}) |
||||
|
||||
test('change_promise_impl_promise', () => { |
||||
|
||||
promises.use({ |
||||
reject: function (err) { |
||||
expect(err.message).toEqual('fn must be a function'); |
||||
return 'mock'; |
||||
} |
||||
}); |
||||
|
||||
expect(promises.promise('', '', '')).toEqual('mock'); |
||||
|
||||
// need to reset the promise implementation because of require cache
|
||||
promises.use(global.Promise); |
||||
}) |
@ -0,0 +1,55 @@ |
||||
const bcrypt = require('../bcrypt'); |
||||
|
||||
const EXPECTED = 2500; //number of times to iterate these tests.)
|
||||
const { TEST_TIMEOUT_SECONDS } = process.env; |
||||
let timeout = 5e3; // default test timeout
|
||||
|
||||
// it is necessary to increase the test timeout when emulating cross-architecture
|
||||
// environments (i.e. arm64 from x86-64 host) which have significantly reduced performance:
|
||||
if ( TEST_TIMEOUT_SECONDS ) |
||||
timeout = Number.parseInt(TEST_TIMEOUT_SECONDS, 10) * 1e3; |
||||
|
||||
jest.setTimeout(timeout); |
||||
|
||||
test('salt_length', () => { |
||||
expect.assertions(EXPECTED); |
||||
|
||||
return Promise.all(Array.from({length: EXPECTED}, |
||||
() => bcrypt.genSalt(10) |
||||
.then(salt => expect(salt).toHaveLength(29)))); |
||||
}) |
||||
|
||||
test('test_hash_length', () => { |
||||
expect.assertions(EXPECTED); |
||||
const SALT = '$2a$04$TnjywYklQbbZjdjBgBoA4e'; |
||||
return Promise.all(Array.from({length: EXPECTED}, |
||||
() => bcrypt.hash('test', SALT) |
||||
.then(hash => expect(hash).toHaveLength(60)))); |
||||
}) |
||||
|
||||
test('test_compare', () => { |
||||
expect.assertions(EXPECTED); |
||||
const HASH = '$2a$04$TnjywYklQbbZjdjBgBoA4e9G7RJt9blgMgsCvUvus4Iv4TENB5nHy'; |
||||
return Promise.all(Array.from({length: EXPECTED}, |
||||
() => bcrypt.compare('test', HASH) |
||||
.then(match => expect(match).toEqual(true)))); |
||||
}) |
||||
|
||||
test('test_hash_and_compare', () => { |
||||
expect.assertions(EXPECTED * 3); |
||||
const salt = bcrypt.genSaltSync(4) |
||||
|
||||
return Promise.all(Array.from({length: EXPECTED}, |
||||
() => { |
||||
const password = 'secret' + Math.random(); |
||||
return bcrypt.hash(password, salt) |
||||
.then(hash => { |
||||
expect(hash).toHaveLength(60); |
||||
const goodCompare = bcrypt.compare(password, hash).then(res => expect(res).toEqual(true)); |
||||
const badCompare = bcrypt.compare('bad' + password, hash).then(res => expect(res).toEqual(false)); |
||||
|
||||
return Promise.all([goodCompare, badCompare]); |
||||
}); |
||||
})); |
||||
}, timeout * 3); |
||||
|
@ -0,0 +1,125 @@ |
||||
const bcrypt = require('../bcrypt') |
||||
|
||||
test('salt_length', () => { |
||||
const salt = bcrypt.genSaltSync(13); |
||||
expect(salt).toHaveLength(29); |
||||
const [_, version, rounds] = salt.split('$'); |
||||
expect(version).toStrictEqual('2b') |
||||
expect(rounds).toStrictEqual('13') |
||||
}) |
||||
|
||||
test('salt_no_params', () => { |
||||
const salt = bcrypt.genSaltSync(); |
||||
const [_, version, rounds] = salt.split('$'); |
||||
expect(version).toStrictEqual('2b') |
||||
expect(rounds).toStrictEqual('10') |
||||
}) |
||||
|
||||
test('salt_rounds_is_string_number', () => { |
||||
expect(() => bcrypt.genSaltSync('10')).toThrowError('rounds must be a number'); |
||||
}) |
||||
|
||||
test('salt_rounds_is_NaN', () => { |
||||
expect(() => bcrypt.genSaltSync('b')).toThrowError("rounds must be a number"); |
||||
}) |
||||
|
||||
test('salt_minor_a', () => { |
||||
const salt = bcrypt.genSaltSync(10, 'a'); |
||||
const [_, version, rounds] = salt.split('$'); |
||||
expect(version).toStrictEqual('2a') |
||||
expect(rounds).toStrictEqual('10') |
||||
}) |
||||
|
||||
test('salt_minor_b', () => { |
||||
const salt = bcrypt.genSaltSync(10, 'b'); |
||||
const [_, version, rounds] = salt.split('$'); |
||||
expect(version).toStrictEqual('2b') |
||||
expect(rounds).toStrictEqual('10') |
||||
}) |
||||
|
||||
test('hash', () => { |
||||
expect(() => bcrypt.hashSync('password', bcrypt.genSaltSync(10))).not.toThrow() |
||||
}) |
||||
|
||||
test('hash_rounds', () => { |
||||
const hash = bcrypt.hashSync('password', 8); |
||||
expect(bcrypt.getRounds(hash)).toStrictEqual(8) |
||||
}) |
||||
|
||||
test('hash_empty_string', () => { |
||||
expect(() => bcrypt.hashSync('', bcrypt.genSaltSync(10))).not.toThrow(); |
||||
expect(() => bcrypt.hashSync('password', '')).toThrowError('Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue'); |
||||
expect(() => bcrypt.hashSync('', '')).toThrowError('Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue'); |
||||
}) |
||||
|
||||
test('hash_pw_no_params', () => { |
||||
expect(() => bcrypt.hashSync()).toThrow('data and salt arguments required'); |
||||
}) |
||||
|
||||
test('hash_pw_one_param', () => { |
||||
expect(() => bcrypt.hashSync('password')).toThrow('data and salt arguments required'); |
||||
}) |
||||
|
||||
test('hash_pw_not_hash_str', () => { |
||||
expect(() => bcrypt.hashSync('password', {})).toThrow("data must be a string or Buffer and salt must either be a salt string or a number of rounds") |
||||
}) |
||||
|
||||
test('hash_salt_validity', () => { |
||||
expect(2); |
||||
expect(bcrypt.hashSync('password', '$2a$10$somesaltyvaluertsetrse')).toBeDefined() |
||||
expect(() => bcrypt.hashSync('password', 'some$value')).toThrow('Invalid salt. Salt must be in the form of: $Vers$log2(NumRounds)$saltvalue') |
||||
}) |
||||
|
||||
test('verify_salt', () => { |
||||
const salt = bcrypt.genSaltSync(10); |
||||
const split_salt = salt.split('$'); |
||||
expect(split_salt[1]).toStrictEqual('2b') |
||||
expect(split_salt[2]).toStrictEqual('10') |
||||
}) |
||||
|
||||
test('verify_salt_min_rounds', () => { |
||||
const salt = bcrypt.genSaltSync(1); |
||||
const split_salt = salt.split('$'); |
||||
expect(split_salt[1]).toStrictEqual('2b') |
||||
expect(split_salt[2]).toStrictEqual('04') |
||||
}) |
||||
|
||||
test('verify_salt_max_rounds', () => { |
||||
const salt = bcrypt.genSaltSync(100); |
||||
const split_salt = salt.split('$'); |
||||
expect(split_salt[1]).toStrictEqual('2b') |
||||
expect(split_salt[2]).toStrictEqual('31') |
||||
}) |
||||
|
||||
test('hash_compare', () => { |
||||
const salt = bcrypt.genSaltSync(10); |
||||
expect(29).toStrictEqual(salt.length) |
||||
const hash = bcrypt.hashSync("test", salt); |
||||
expect(bcrypt.compareSync("test", hash)).toBeDefined() |
||||
expect(!(bcrypt.compareSync("blah", hash))).toBeDefined() |
||||
}) |
||||
|
||||
test('hash_compare_empty_strings', () => { |
||||
expect(!(bcrypt.compareSync("", "password"))).toBeDefined() |
||||
expect(!(bcrypt.compareSync("", ""))).toBeDefined() |
||||
expect(!(bcrypt.compareSync("password", ""))).toBeDefined() |
||||
}) |
||||
|
||||
test('hash_compare_invalid_strings', () => { |
||||
const fullString = 'envy1362987212538'; |
||||
const hash = '$2a$10$XOPbrlUPQdwdJUpSrIF6X.LbE14qsMmKGhM1A8W9iqaG3vv1BD7WC'; |
||||
const wut = ':'; |
||||
expect(bcrypt.compareSync(fullString, hash)).toBe(true); |
||||
expect(bcrypt.compareSync(fullString, wut)).toBe(false); |
||||
}) |
||||
|
||||
test('getRounds', () => { |
||||
const hash = bcrypt.hashSync("test", bcrypt.genSaltSync(9)); |
||||
expect(9).toStrictEqual(bcrypt.getRounds(hash)) |
||||
}) |
||||
|
||||
test('getRounds', () => { |
||||
const hash = bcrypt.hashSync("test", bcrypt.genSaltSync(9)); |
||||
expect(9).toStrictEqual(bcrypt.getRounds(hash)) |
||||
expect(() => bcrypt.getRounds('')).toThrow("invalid hash provided"); |
||||
}); |
@ -0,0 +1,7 @@ |
||||
# Deprecated Package |
||||
|
||||
This package is no longer supported and has been deprecated. To avoid malicious use, npm is hanging on to the package name. |
||||
|
||||
It's now a built-in Node module. If you've depended on crypto, you should switch to the one that's built-in. |
||||
|
||||
Please contact support@npmjs.com if you have questions about this package. |
@ -0,0 +1,19 @@ |
||||
{ |
||||
"name": "crypto", |
||||
"version": "1.0.1", |
||||
"description": "", |
||||
"main": "index.js", |
||||
"scripts": { |
||||
"test": "echo \"Error: no test specified\" && exit 1" |
||||
}, |
||||
"repository": { |
||||
"type": "git", |
||||
"url": "git+https://github.com/npm/deprecate-holder.git" |
||||
}, |
||||
"author": "", |
||||
"license": "ISC", |
||||
"bugs": { |
||||
"url": "https://github.com/npm/deprecate-holder/issues" |
||||
}, |
||||
"homepage": "https://github.com/npm/deprecate-holder#readme" |
||||
} |
@ -0,0 +1,47 @@ |
||||
Copyright OpenJS Foundation and other contributors <https://openjsf.org/> |
||||
|
||||
Based on Underscore.js, copyright Jeremy Ashkenas, |
||||
DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/> |
||||
|
||||
This software consists of voluntary contributions made by many |
||||
individuals. For exact contribution history, see the revision history |
||||
available at https://github.com/lodash/lodash |
||||
|
||||
The following license applies to all parts of this software except as |
||||
documented below: |
||||
|
||||
==== |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining |
||||
a copy of this software and associated documentation files (the |
||||
"Software"), to deal in the Software without restriction, including |
||||
without limitation the rights to use, copy, modify, merge, publish, |
||||
distribute, sublicense, and/or sell copies of the Software, and to |
||||
permit persons to whom the Software is furnished to do so, subject to |
||||
the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be |
||||
included in all copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||||
|
||||
==== |
||||
|
||||
Copyright and related rights for sample code are waived via CC0. Sample |
||||
code is defined as all source code displayed within the prose of the |
||||
documentation. |
||||
|
||||
CC0: http://creativecommons.org/publicdomain/zero/1.0/ |
||||
|
||||
==== |
||||
|
||||
Files located in the node_modules and vendor directories are externally |
||||
maintained libraries used by this software which have their own |
||||
licenses; we recommend you read them, as their terms may differ from the |
||||
terms above. |
@ -0,0 +1,39 @@ |
||||
# lodash v4.17.21 |
||||
|
||||
The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules. |
||||
|
||||
## Installation |
||||
|
||||
Using npm: |
||||
```shell |
||||
$ npm i -g npm |
||||
$ npm i --save lodash |
||||
``` |
||||
|
||||
In Node.js: |
||||
```js |
||||
// Load the full build. |
||||
var _ = require('lodash'); |
||||
// Load the core build. |
||||
var _ = require('lodash/core'); |
||||
// Load the FP build for immutable auto-curried iteratee-first data-last methods. |
||||
var fp = require('lodash/fp'); |
||||
|
||||
// Load method categories. |
||||
var array = require('lodash/array'); |
||||
var object = require('lodash/fp/object'); |
||||
|
||||
// Cherry-pick methods for smaller browserify/rollup/webpack bundles. |
||||
var at = require('lodash/at'); |
||||
var curryN = require('lodash/fp/curryN'); |
||||
``` |
||||
|
||||
See the [package source](https://github.com/lodash/lodash/tree/4.17.21-npm) for more details. |
||||
|
||||
**Note:**<br> |
||||
Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL. |
||||
|
||||
## Support |
||||
|
||||
Tested in Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12.<br> |
||||
Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available. |
@ -0,0 +1,7 @@ |
||||
var getNative = require('./_getNative'), |
||||
root = require('./_root'); |
||||
|
||||
/* Built-in method references that are verified to be native. */ |
||||
var DataView = getNative(root, 'DataView'); |
||||
|
||||
module.exports = DataView; |
@ -0,0 +1,32 @@ |
||||
var hashClear = require('./_hashClear'), |
||||
hashDelete = require('./_hashDelete'), |
||||
hashGet = require('./_hashGet'), |
||||
hashHas = require('./_hashHas'), |
||||
hashSet = require('./_hashSet'); |
||||
|
||||
/** |
||||
* Creates a hash object. |
||||
* |
||||
* @private |
||||
* @constructor |
||||
* @param {Array} [entries] The key-value pairs to cache. |
||||
*/ |
||||
function Hash(entries) { |
||||
var index = -1, |
||||
length = entries == null ? 0 : entries.length; |
||||
|
||||
this.clear(); |
||||
while (++index < length) { |
||||
var entry = entries[index]; |
||||
this.set(entry[0], entry[1]); |
||||
} |
||||
} |
||||
|
||||
// Add methods to `Hash`.
|
||||
Hash.prototype.clear = hashClear; |
||||
Hash.prototype['delete'] = hashDelete; |
||||
Hash.prototype.get = hashGet; |
||||
Hash.prototype.has = hashHas; |
||||
Hash.prototype.set = hashSet; |
||||
|
||||
module.exports = Hash; |
@ -0,0 +1,28 @@ |
||||
var baseCreate = require('./_baseCreate'), |
||||
baseLodash = require('./_baseLodash'); |
||||
|
||||
/** Used as references for the maximum length and index of an array. */ |
||||
var MAX_ARRAY_LENGTH = 4294967295; |
||||
|
||||
/** |
||||
* Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. |
||||
* |
||||
* @private |
||||
* @constructor |
||||
* @param {*} value The value to wrap. |
||||
*/ |
||||
function LazyWrapper(value) { |
||||
this.__wrapped__ = value; |
||||
this.__actions__ = []; |
||||
this.__dir__ = 1; |
||||
this.__filtered__ = false; |
||||
this.__iteratees__ = []; |
||||
this.__takeCount__ = MAX_ARRAY_LENGTH; |
||||
this.__views__ = []; |
||||
} |
||||
|
||||
// Ensure `LazyWrapper` is an instance of `baseLodash`.
|
||||
LazyWrapper.prototype = baseCreate(baseLodash.prototype); |
||||
LazyWrapper.prototype.constructor = LazyWrapper; |
||||
|
||||
module.exports = LazyWrapper; |
@ -0,0 +1,32 @@ |
||||
var listCacheClear = require('./_listCacheClear'), |
||||
listCacheDelete = require('./_listCacheDelete'), |
||||
listCacheGet = require('./_listCacheGet'), |
||||
listCacheHas = require('./_listCacheHas'), |
||||
listCacheSet = require('./_listCacheSet'); |
||||
|
||||
/** |
||||
* Creates an list cache object. |
||||
* |
||||
* @private |
||||
* @constructor |
||||
* @param {Array} [entries] The key-value pairs to cache. |
||||
*/ |
||||
function ListCache(entries) { |
||||
var index = -1, |
||||
length = entries == null ? 0 : entries.length; |
||||
|
||||
this.clear(); |
||||
while (++index < length) { |
||||
var entry = entries[index]; |
||||
this.set(entry[0], entry[1]); |
||||
} |
||||
} |
||||
|
||||
// Add methods to `ListCache`.
|
||||
ListCache.prototype.clear = listCacheClear; |
||||
ListCache.prototype['delete'] = listCacheDelete; |
||||
ListCache.prototype.get = listCacheGet; |
||||
ListCache.prototype.has = listCacheHas; |
||||
ListCache.prototype.set = listCacheSet; |
||||
|
||||
module.exports = ListCache; |
@ -0,0 +1,22 @@ |
||||
var baseCreate = require('./_baseCreate'), |
||||
baseLodash = require('./_baseLodash'); |
||||
|
||||
/** |
||||
* The base constructor for creating `lodash` wrapper objects. |
||||
* |
||||
* @private |
||||
* @param {*} value The value to wrap. |
||||
* @param {boolean} [chainAll] Enable explicit method chain sequences. |
||||
*/ |
||||
function LodashWrapper(value, chainAll) { |
||||
this.__wrapped__ = value; |
||||
this.__actions__ = []; |
||||
this.__chain__ = !!chainAll; |
||||
this.__index__ = 0; |
||||
this.__values__ = undefined; |
||||
} |
||||
|
||||
LodashWrapper.prototype = baseCreate(baseLodash.prototype); |
||||
LodashWrapper.prototype.constructor = LodashWrapper; |
||||
|
||||
module.exports = LodashWrapper; |
@ -0,0 +1,7 @@ |
||||
var getNative = require('./_getNative'), |
||||
root = require('./_root'); |
||||
|
||||
/* Built-in method references that are verified to be native. */ |
||||
var Map = getNative(root, 'Map'); |
||||
|
||||
module.exports = Map; |
@ -0,0 +1,32 @@ |
||||
var mapCacheClear = require('./_mapCacheClear'), |
||||
mapCacheDelete = require('./_mapCacheDelete'), |
||||
mapCacheGet = require('./_mapCacheGet'), |
||||
mapCacheHas = require('./_mapCacheHas'), |
||||
mapCacheSet = require('./_mapCacheSet'); |
||||
|
||||
/** |
||||
* Creates a map cache object to store key-value pairs. |
||||
* |
||||
* @private |
||||
* @constructor |
||||
* @param {Array} [entries] The key-value pairs to cache. |
||||
*/ |
||||
function MapCache(entries) { |
||||
var index = -1, |
||||
length = entries == null ? 0 : entries.length; |
||||
|
||||
this.clear(); |
||||
while (++index < length) { |
||||
var entry = entries[index]; |
||||
this.set(entry[0], entry[1]); |
||||
} |
||||
} |
||||
|
||||
// Add methods to `MapCache`.
|
||||
MapCache.prototype.clear = mapCacheClear; |
||||
MapCache.prototype['delete'] = mapCacheDelete; |
||||
MapCache.prototype.get = mapCacheGet; |
||||
MapCache.prototype.has = mapCacheHas; |
||||
MapCache.prototype.set = mapCacheSet; |
||||
|
||||
module.exports = MapCache; |
@ -0,0 +1,7 @@ |
||||
var getNative = require('./_getNative'), |
||||
root = require('./_root'); |
||||
|
||||
/* Built-in method references that are verified to be native. */ |
||||
var Promise = getNative(root, 'Promise'); |
||||
|
||||
module.exports = Promise; |
@ -0,0 +1,7 @@ |
||||
var getNative = require('./_getNative'), |
||||
root = require('./_root'); |
||||
|
||||
/* Built-in method references that are verified to be native. */ |
||||
var Set = getNative(root, 'Set'); |
||||
|
||||
module.exports = Set; |
@ -0,0 +1,27 @@ |
||||
var MapCache = require('./_MapCache'), |
||||
setCacheAdd = require('./_setCacheAdd'), |
||||
setCacheHas = require('./_setCacheHas'); |
||||
|
||||
/** |
||||
* |
||||
* Creates an array cache object to store unique values. |
||||
* |
||||
* @private |
||||
* @constructor |
||||
* @param {Array} [values] The values to cache. |
||||
*/ |
||||
function SetCache(values) { |
||||
var index = -1, |
||||
length = values == null ? 0 : values.length; |
||||
|
||||
this.__data__ = new MapCache; |
||||
while (++index < length) { |
||||
this.add(values[index]); |
||||
} |
||||
} |
||||
|
||||
// Add methods to `SetCache`.
|
||||
SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; |
||||
SetCache.prototype.has = setCacheHas; |
||||
|
||||
module.exports = SetCache; |
@ -0,0 +1,27 @@ |
||||
var ListCache = require('./_ListCache'), |
||||
stackClear = require('./_stackClear'), |
||||
stackDelete = require('./_stackDelete'), |
||||
stackGet = require('./_stackGet'), |
||||
stackHas = require('./_stackHas'), |
||||
stackSet = require('./_stackSet'); |
||||
|
||||
/** |
||||
* Creates a stack cache object to store key-value pairs. |
||||
* |
||||
* @private |
||||
* @constructor |
||||
* @param {Array} [entries] The key-value pairs to cache. |
||||
*/ |
||||
function Stack(entries) { |
||||
var data = this.__data__ = new ListCache(entries); |
||||
this.size = data.size; |
||||
} |
||||
|
||||
// Add methods to `Stack`.
|
||||
Stack.prototype.clear = stackClear; |
||||
Stack.prototype['delete'] = stackDelete; |
||||
Stack.prototype.get = stackGet; |
||||
Stack.prototype.has = stackHas; |
||||
Stack.prototype.set = stackSet; |
||||
|
||||
module.exports = Stack; |
@ -0,0 +1,6 @@ |
||||
var root = require('./_root'); |
||||
|
||||
/** Built-in value references. */ |
||||
var Symbol = root.Symbol; |
||||
|
||||
module.exports = Symbol; |
@ -0,0 +1,6 @@ |
||||
var root = require('./_root'); |
||||
|
||||
/** Built-in value references. */ |
||||
var Uint8Array = root.Uint8Array; |
||||
|
||||
module.exports = Uint8Array; |
@ -0,0 +1,7 @@ |
||||
var getNative = require('./_getNative'), |
||||
root = require('./_root'); |
||||
|
||||
/* Built-in method references that are verified to be native. */ |
||||
var WeakMap = getNative(root, 'WeakMap'); |
||||
|
||||
module.exports = WeakMap; |
@ -0,0 +1,21 @@ |
||||
/** |
||||
* A faster alternative to `Function#apply`, this function invokes `func` |
||||
* with the `this` binding of `thisArg` and the arguments of `args`. |
||||
* |
||||
* @private |
||||
* @param {Function} func The function to invoke. |
||||
* @param {*} thisArg The `this` binding of `func`. |
||||
* @param {Array} args The arguments to invoke `func` with. |
||||
* @returns {*} Returns the result of `func`. |
||||
*/ |
||||
function apply(func, thisArg, args) { |
||||
switch (args.length) { |
||||
case 0: return func.call(thisArg); |
||||
case 1: return func.call(thisArg, args[0]); |
||||
case 2: return func.call(thisArg, args[0], args[1]); |
||||
case 3: return func.call(thisArg, args[0], args[1], args[2]); |
||||
} |
||||
return func.apply(thisArg, args); |
||||
} |
||||
|
||||
module.exports = apply; |
@ -0,0 +1,22 @@ |
||||
/** |
||||
* A specialized version of `baseAggregator` for arrays. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} setter The function to set `accumulator` values. |
||||
* @param {Function} iteratee The iteratee to transform keys. |
||||
* @param {Object} accumulator The initial aggregated object. |
||||
* @returns {Function} Returns `accumulator`. |
||||
*/ |
||||
function arrayAggregator(array, setter, iteratee, accumulator) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length; |
||||
|
||||
while (++index < length) { |
||||
var value = array[index]; |
||||
setter(accumulator, value, iteratee(value), array); |
||||
} |
||||
return accumulator; |
||||
} |
||||
|
||||
module.exports = arrayAggregator; |
@ -0,0 +1,22 @@ |
||||
/** |
||||
* A specialized version of `_.forEach` for arrays without support for |
||||
* iteratee shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} iteratee The function invoked per iteration. |
||||
* @returns {Array} Returns `array`. |
||||
*/ |
||||
function arrayEach(array, iteratee) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length; |
||||
|
||||
while (++index < length) { |
||||
if (iteratee(array[index], index, array) === false) { |
||||
break; |
||||
} |
||||
} |
||||
return array; |
||||
} |
||||
|
||||
module.exports = arrayEach; |
@ -0,0 +1,21 @@ |
||||
/** |
||||
* A specialized version of `_.forEachRight` for arrays without support for |
||||
* iteratee shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} iteratee The function invoked per iteration. |
||||
* @returns {Array} Returns `array`. |
||||
*/ |
||||
function arrayEachRight(array, iteratee) { |
||||
var length = array == null ? 0 : array.length; |
||||
|
||||
while (length--) { |
||||
if (iteratee(array[length], length, array) === false) { |
||||
break; |
||||
} |
||||
} |
||||
return array; |
||||
} |
||||
|
||||
module.exports = arrayEachRight; |
@ -0,0 +1,23 @@ |
||||
/** |
||||
* A specialized version of `_.every` for arrays without support for |
||||
* iteratee shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} predicate The function invoked per iteration. |
||||
* @returns {boolean} Returns `true` if all elements pass the predicate check, |
||||
* else `false`. |
||||
*/ |
||||
function arrayEvery(array, predicate) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length; |
||||
|
||||
while (++index < length) { |
||||
if (!predicate(array[index], index, array)) { |
||||
return false; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
module.exports = arrayEvery; |
@ -0,0 +1,25 @@ |
||||
/** |
||||
* A specialized version of `_.filter` for arrays without support for |
||||
* iteratee shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} predicate The function invoked per iteration. |
||||
* @returns {Array} Returns the new filtered array. |
||||
*/ |
||||
function arrayFilter(array, predicate) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length, |
||||
resIndex = 0, |
||||
result = []; |
||||
|
||||
while (++index < length) { |
||||
var value = array[index]; |
||||
if (predicate(value, index, array)) { |
||||
result[resIndex++] = value; |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
module.exports = arrayFilter; |
@ -0,0 +1,17 @@ |
||||
var baseIndexOf = require('./_baseIndexOf'); |
||||
|
||||
/** |
||||
* A specialized version of `_.includes` for arrays without support for |
||||
* specifying an index to search from. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to inspect. |
||||
* @param {*} target The value to search for. |
||||
* @returns {boolean} Returns `true` if `target` is found, else `false`. |
||||
*/ |
||||
function arrayIncludes(array, value) { |
||||
var length = array == null ? 0 : array.length; |
||||
return !!length && baseIndexOf(array, value, 0) > -1; |
||||
} |
||||
|
||||
module.exports = arrayIncludes; |
@ -0,0 +1,22 @@ |
||||
/** |
||||
* This function is like `arrayIncludes` except that it accepts a comparator. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to inspect. |
||||
* @param {*} target The value to search for. |
||||
* @param {Function} comparator The comparator invoked per element. |
||||
* @returns {boolean} Returns `true` if `target` is found, else `false`. |
||||
*/ |
||||
function arrayIncludesWith(array, value, comparator) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length; |
||||
|
||||
while (++index < length) { |
||||
if (comparator(value, array[index])) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
module.exports = arrayIncludesWith; |
@ -0,0 +1,49 @@ |
||||
var baseTimes = require('./_baseTimes'), |
||||
isArguments = require('./isArguments'), |
||||
isArray = require('./isArray'), |
||||
isBuffer = require('./isBuffer'), |
||||
isIndex = require('./_isIndex'), |
||||
isTypedArray = require('./isTypedArray'); |
||||
|
||||
/** Used for built-in method references. */ |
||||
var objectProto = Object.prototype; |
||||
|
||||
/** Used to check objects for own properties. */ |
||||
var hasOwnProperty = objectProto.hasOwnProperty; |
||||
|
||||
/** |
||||
* Creates an array of the enumerable property names of the array-like `value`. |
||||
* |
||||
* @private |
||||
* @param {*} value The value to query. |
||||
* @param {boolean} inherited Specify returning inherited property names. |
||||
* @returns {Array} Returns the array of property names. |
||||
*/ |
||||
function arrayLikeKeys(value, inherited) { |
||||
var isArr = isArray(value), |
||||
isArg = !isArr && isArguments(value), |
||||
isBuff = !isArr && !isArg && isBuffer(value), |
||||
isType = !isArr && !isArg && !isBuff && isTypedArray(value), |
||||
skipIndexes = isArr || isArg || isBuff || isType, |
||||
result = skipIndexes ? baseTimes(value.length, String) : [], |
||||
length = result.length; |
||||
|
||||
for (var key in value) { |
||||
if ((inherited || hasOwnProperty.call(value, key)) && |
||||
!(skipIndexes && ( |
||||
// Safari 9 has enumerable `arguments.length` in strict mode.
|
||||
key == 'length' || |
||||
// Node.js 0.10 has enumerable non-index properties on buffers.
|
||||
(isBuff && (key == 'offset' || key == 'parent')) || |
||||
// PhantomJS 2 has enumerable non-index properties on typed arrays.
|
||||
(isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || |
||||
// Skip index properties.
|
||||
isIndex(key, length) |
||||
))) { |
||||
result.push(key); |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
module.exports = arrayLikeKeys; |
@ -0,0 +1,21 @@ |
||||
/** |
||||
* A specialized version of `_.map` for arrays without support for iteratee |
||||
* shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} iteratee The function invoked per iteration. |
||||
* @returns {Array} Returns the new mapped array. |
||||
*/ |
||||
function arrayMap(array, iteratee) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length, |
||||
result = Array(length); |
||||
|
||||
while (++index < length) { |
||||
result[index] = iteratee(array[index], index, array); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
module.exports = arrayMap; |
@ -0,0 +1,20 @@ |
||||
/** |
||||
* Appends the elements of `values` to `array`. |
||||
* |
||||
* @private |
||||
* @param {Array} array The array to modify. |
||||
* @param {Array} values The values to append. |
||||
* @returns {Array} Returns `array`. |
||||
*/ |
||||
function arrayPush(array, values) { |
||||
var index = -1, |
||||
length = values.length, |
||||
offset = array.length; |
||||
|
||||
while (++index < length) { |
||||
array[offset + index] = values[index]; |
||||
} |
||||
return array; |
||||
} |
||||
|
||||
module.exports = arrayPush; |
@ -0,0 +1,26 @@ |
||||
/** |
||||
* A specialized version of `_.reduce` for arrays without support for |
||||
* iteratee shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} iteratee The function invoked per iteration. |
||||
* @param {*} [accumulator] The initial value. |
||||
* @param {boolean} [initAccum] Specify using the first element of `array` as |
||||
* the initial value. |
||||
* @returns {*} Returns the accumulated value. |
||||
*/ |
||||
function arrayReduce(array, iteratee, accumulator, initAccum) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length; |
||||
|
||||
if (initAccum && length) { |
||||
accumulator = array[++index]; |
||||
} |
||||
while (++index < length) { |
||||
accumulator = iteratee(accumulator, array[index], index, array); |
||||
} |
||||
return accumulator; |
||||
} |
||||
|
||||
module.exports = arrayReduce; |
@ -0,0 +1,24 @@ |
||||
/** |
||||
* A specialized version of `_.reduceRight` for arrays without support for |
||||
* iteratee shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} iteratee The function invoked per iteration. |
||||
* @param {*} [accumulator] The initial value. |
||||
* @param {boolean} [initAccum] Specify using the last element of `array` as |
||||
* the initial value. |
||||
* @returns {*} Returns the accumulated value. |
||||
*/ |
||||
function arrayReduceRight(array, iteratee, accumulator, initAccum) { |
||||
var length = array == null ? 0 : array.length; |
||||
if (initAccum && length) { |
||||
accumulator = array[--length]; |
||||
} |
||||
while (length--) { |
||||
accumulator = iteratee(accumulator, array[length], length, array); |
||||
} |
||||
return accumulator; |
||||
} |
||||
|
||||
module.exports = arrayReduceRight; |
@ -0,0 +1,15 @@ |
||||
var baseRandom = require('./_baseRandom'); |
||||
|
||||
/** |
||||
* A specialized version of `_.sample` for arrays. |
||||
* |
||||
* @private |
||||
* @param {Array} array The array to sample. |
||||
* @returns {*} Returns the random element. |
||||
*/ |
||||
function arraySample(array) { |
||||
var length = array.length; |
||||
return length ? array[baseRandom(0, length - 1)] : undefined; |
||||
} |
||||
|
||||
module.exports = arraySample; |
@ -0,0 +1,17 @@ |
||||
var baseClamp = require('./_baseClamp'), |
||||
copyArray = require('./_copyArray'), |
||||
shuffleSelf = require('./_shuffleSelf'); |
||||
|
||||
/** |
||||
* A specialized version of `_.sampleSize` for arrays. |
||||
* |
||||
* @private |
||||
* @param {Array} array The array to sample. |
||||
* @param {number} n The number of elements to sample. |
||||
* @returns {Array} Returns the random elements. |
||||
*/ |
||||
function arraySampleSize(array, n) { |
||||
return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length)); |
||||
} |
||||
|
||||
module.exports = arraySampleSize; |
@ -0,0 +1,15 @@ |
||||
var copyArray = require('./_copyArray'), |
||||
shuffleSelf = require('./_shuffleSelf'); |
||||
|
||||
/** |
||||
* A specialized version of `_.shuffle` for arrays. |
||||
* |
||||
* @private |
||||
* @param {Array} array The array to shuffle. |
||||
* @returns {Array} Returns the new shuffled array. |
||||
*/ |
||||
function arrayShuffle(array) { |
||||
return shuffleSelf(copyArray(array)); |
||||
} |
||||
|
||||
module.exports = arrayShuffle; |
@ -0,0 +1,23 @@ |
||||
/** |
||||
* A specialized version of `_.some` for arrays without support for iteratee |
||||
* shorthands. |
||||
* |
||||
* @private |
||||
* @param {Array} [array] The array to iterate over. |
||||
* @param {Function} predicate The function invoked per iteration. |
||||
* @returns {boolean} Returns `true` if any element passes the predicate check, |
||||
* else `false`. |
||||
*/ |
||||
function arraySome(array, predicate) { |
||||
var index = -1, |
||||
length = array == null ? 0 : array.length; |
||||
|
||||
while (++index < length) { |
||||
if (predicate(array[index], index, array)) { |
||||
return true; |
||||
} |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
module.exports = arraySome; |
@ -0,0 +1,12 @@ |
||||
var baseProperty = require('./_baseProperty'); |
||||
|
||||
/** |
||||
* Gets the size of an ASCII `string`. |
||||
* |
||||
* @private |
||||
* @param {string} string The string inspect. |
||||
* @returns {number} Returns the string size. |
||||
*/ |
||||
var asciiSize = baseProperty('length'); |
||||
|
||||
module.exports = asciiSize; |
@ -0,0 +1,12 @@ |
||||
/** |
||||
* Converts an ASCII `string` to an array. |
||||
* |
||||
* @private |
||||
* @param {string} string The string to convert. |
||||
* @returns {Array} Returns the converted array. |
||||
*/ |
||||
function asciiToArray(string) { |
||||
return string.split(''); |
||||
} |
||||
|
||||
module.exports = asciiToArray; |
@ -0,0 +1,15 @@ |
||||
/** Used to match words composed of alphanumeric characters. */ |
||||
var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g; |
||||
|
||||
/** |
||||
* Splits an ASCII `string` into an array of its words. |
||||
* |
||||
* @private |
||||
* @param {string} The string to inspect. |
||||
* @returns {Array} Returns the words of `string`. |
||||
*/ |
||||
function asciiWords(string) { |
||||
return string.match(reAsciiWord) || []; |
||||
} |
||||
|
||||
module.exports = asciiWords; |
@ -0,0 +1,20 @@ |
||||
var baseAssignValue = require('./_baseAssignValue'), |
||||
eq = require('./eq'); |
||||
|
||||
/** |
||||
* This function is like `assignValue` except that it doesn't assign |
||||
* `undefined` values. |
||||
* |
||||
* @private |
||||
* @param {Object} object The object to modify. |
||||
* @param {string} key The key of the property to assign. |
||||
* @param {*} value The value to assign. |
||||
*/ |
||||
function assignMergeValue(object, key, value) { |
||||
if ((value !== undefined && !eq(object[key], value)) || |
||||
(value === undefined && !(key in object))) { |
||||
baseAssignValue(object, key, value); |
||||
} |
||||
} |
||||
|
||||
module.exports = assignMergeValue; |
@ -0,0 +1,28 @@ |
||||
var baseAssignValue = require('./_baseAssignValue'), |
||||
eq = require('./eq'); |
||||
|
||||
/** Used for built-in method references. */ |
||||
var objectProto = Object.prototype; |
||||
|
||||
/** Used to check objects for own properties. */ |
||||
var hasOwnProperty = objectProto.hasOwnProperty; |
||||
|
||||
/** |
||||
* Assigns `value` to `key` of `object` if the existing value is not equivalent |
||||
* using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
|
||||
* for equality comparisons. |
||||
* |
||||
* @private |
||||
* @param {Object} object The object to modify. |
||||
* @param {string} key The key of the property to assign. |
||||
* @param {*} value The value to assign. |
||||
*/ |
||||
function assignValue(object, key, value) { |
||||
var objValue = object[key]; |
||||
if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || |
||||
(value === undefined && !(key in object))) { |
||||
baseAssignValue(object, key, value); |
||||
} |
||||
} |
||||
|
||||
module.exports = assignValue; |
@ -0,0 +1,21 @@ |
||||
var eq = require('./eq'); |
||||
|
||||
/** |
||||
* Gets the index at which the `key` is found in `array` of key-value pairs. |
||||
* |
||||
* @private |
||||
* @param {Array} array The array to inspect. |
||||
* @param {*} key The key to search for. |
||||
* @returns {number} Returns the index of the matched value, else `-1`. |
||||
*/ |
||||
function assocIndexOf(array, key) { |
||||
var length = array.length; |
||||
while (length--) { |
||||
if (eq(array[length][0], key)) { |
||||
return length; |
||||
} |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
module.exports = assocIndexOf; |
@ -0,0 +1,21 @@ |
||||
var baseEach = require('./_baseEach'); |
||||
|
||||
/** |
||||
* Aggregates elements of `collection` on `accumulator` with keys transformed |
||||
* by `iteratee` and values set by `setter`. |
||||
* |
||||
* @private |
||||
* @param {Array|Object} collection The collection to iterate over. |
||||
* @param {Function} setter The function to set `accumulator` values. |
||||
* @param {Function} iteratee The iteratee to transform keys. |
||||
* @param {Object} accumulator The initial aggregated object. |
||||
* @returns {Function} Returns `accumulator`. |
||||
*/ |
||||
function baseAggregator(collection, setter, iteratee, accumulator) { |
||||
baseEach(collection, function(value, key, collection) { |
||||
setter(accumulator, value, iteratee(value), collection); |
||||
}); |
||||
return accumulator; |
||||
} |
||||
|
||||
module.exports = baseAggregator; |
@ -0,0 +1,17 @@ |
||||
var copyObject = require('./_copyObject'), |
||||
keys = require('./keys'); |
||||
|
||||
/** |
||||
* The base implementation of `_.assign` without support for multiple sources |
||||
* or `customizer` functions. |
||||
* |
||||
* @private |
||||
* @param {Object} object The destination object. |
||||
* @param {Object} source The source object. |
||||
* @returns {Object} Returns `object`. |
||||
*/ |
||||
function baseAssign(object, source) { |
||||
return object && copyObject(source, keys(source), object); |
||||
} |
||||
|
||||
module.exports = baseAssign; |
@ -0,0 +1,17 @@ |
||||
var copyObject = require('./_copyObject'), |
||||
keysIn = require('./keysIn'); |
||||
|
||||
/** |
||||
* The base implementation of `_.assignIn` without support for multiple sources |
||||
* or `customizer` functions. |
||||
* |
||||
* @private |
||||
* @param {Object} object The destination object. |
||||
* @param {Object} source The source object. |
||||
* @returns {Object} Returns `object`. |
||||
*/ |
||||
function baseAssignIn(object, source) { |
||||
return object && copyObject(source, keysIn(source), object); |
||||
} |
||||
|
||||
module.exports = baseAssignIn; |
@ -0,0 +1,25 @@ |
||||
var defineProperty = require('./_defineProperty'); |
||||
|
||||
/** |
||||
* The base implementation of `assignValue` and `assignMergeValue` without |
||||
* value checks. |
||||
* |
||||
* @private |
||||
* @param {Object} object The object to modify. |
||||
* @param {string} key The key of the property to assign. |
||||
* @param {*} value The value to assign. |
||||
*/ |
||||
function baseAssignValue(object, key, value) { |
||||
if (key == '__proto__' && defineProperty) { |
||||
defineProperty(object, key, { |
||||
'configurable': true, |
||||
'enumerable': true, |
||||
'value': value, |
||||
'writable': true |
||||
}); |
||||
} else { |
||||
object[key] = value; |
||||
} |
||||
} |
||||
|
||||
module.exports = baseAssignValue; |
@ -0,0 +1,23 @@ |
||||
var get = require('./get'); |
||||
|
||||
/** |
||||
* The base implementation of `_.at` without support for individual paths. |
||||
* |
||||
* @private |
||||
* @param {Object} object The object to iterate over. |
||||
* @param {string[]} paths The property paths to pick. |
||||
* @returns {Array} Returns the picked elements. |
||||
*/ |
||||
function baseAt(object, paths) { |
||||
var index = -1, |
||||
length = paths.length, |
||||
result = Array(length), |
||||
skip = object == null; |
||||
|
||||
while (++index < length) { |
||||
result[index] = skip ? undefined : get(object, paths[index]); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
module.exports = baseAt; |
@ -0,0 +1,22 @@ |
||||
/** |
||||
* The base implementation of `_.clamp` which doesn't coerce arguments. |
||||
* |
||||
* @private |
||||
* @param {number} number The number to clamp. |
||||
* @param {number} [lower] The lower bound. |
||||
* @param {number} upper The upper bound. |
||||
* @returns {number} Returns the clamped number. |
||||
*/ |
||||
function baseClamp(number, lower, upper) { |
||||
if (number === number) { |
||||
if (upper !== undefined) { |
||||
number = number <= upper ? number : upper; |
||||
} |
||||
if (lower !== undefined) { |
||||
number = number >= lower ? number : lower; |
||||
} |
||||
} |
||||
return number; |
||||
} |
||||
|
||||
module.exports = baseClamp; |
@ -0,0 +1,166 @@ |
||||
var Stack = require('./_Stack'), |
||||
arrayEach = require('./_arrayEach'), |
||||
assignValue = require('./_assignValue'), |
||||
baseAssign = require('./_baseAssign'), |
||||
baseAssignIn = require('./_baseAssignIn'), |
||||
cloneBuffer = require('./_cloneBuffer'), |
||||
copyArray = require('./_copyArray'), |
||||
copySymbols = require('./_copySymbols'), |
||||
copySymbolsIn = require('./_copySymbolsIn'), |
||||
getAllKeys = require('./_getAllKeys'), |
||||
getAllKeysIn = require('./_getAllKeysIn'), |
||||
getTag = require('./_getTag'), |
||||
initCloneArray = require('./_initCloneArray'), |
||||
initCloneByTag = require('./_initCloneByTag'), |
||||
initCloneObject = require('./_initCloneObject'), |
||||
isArray = require('./isArray'), |
||||
isBuffer = require('./isBuffer'), |
||||
isMap = require('./isMap'), |
||||
isObject = require('./isObject'), |
||||
isSet = require('./isSet'), |
||||
keys = require('./keys'), |
||||
keysIn = require('./keysIn'); |
||||
|
||||
/** Used to compose bitmasks for cloning. */ |
||||
var CLONE_DEEP_FLAG = 1, |
||||
CLONE_FLAT_FLAG = 2, |
||||
CLONE_SYMBOLS_FLAG = 4; |
||||
|
||||
/** `Object#toString` result references. */ |
||||
var argsTag = '[object Arguments]', |
||||
arrayTag = '[object Array]', |
||||
boolTag = '[object Boolean]', |
||||
dateTag = '[object Date]', |
||||
errorTag = '[object Error]', |
||||
funcTag = '[object Function]', |
||||
genTag = '[object GeneratorFunction]', |
||||
mapTag = '[object Map]', |
||||
numberTag = '[object Number]', |
||||
objectTag = '[object Object]', |
||||
regexpTag = '[object RegExp]', |
||||
setTag = '[object Set]', |
||||
stringTag = '[object String]', |
||||
symbolTag = '[object Symbol]', |
||||
weakMapTag = '[object WeakMap]'; |
||||
|
||||
var arrayBufferTag = '[object ArrayBuffer]', |
||||
dataViewTag = '[object DataView]', |
||||
float32Tag = '[object Float32Array]', |
||||
float64Tag = '[object Float64Array]', |
||||
int8Tag = '[object Int8Array]', |
||||
int16Tag = '[object Int16Array]', |
||||
int32Tag = '[object Int32Array]', |
||||
uint8Tag = '[object Uint8Array]', |
||||
uint8ClampedTag = '[object Uint8ClampedArray]', |
||||
uint16Tag = '[object Uint16Array]', |
||||
uint32Tag = '[object Uint32Array]'; |
||||
|
||||
/** Used to identify `toStringTag` values supported by `_.clone`. */ |
||||
var cloneableTags = {}; |
||||
cloneableTags[argsTag] = cloneableTags[arrayTag] = |
||||
cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = |
||||
cloneableTags[boolTag] = cloneableTags[dateTag] = |
||||
cloneableTags[float32Tag] = cloneableTags[float64Tag] = |
||||
cloneableTags[int8Tag] = cloneableTags[int16Tag] = |
||||
cloneableTags[int32Tag] = cloneableTags[mapTag] = |
||||
cloneableTags[numberTag] = cloneableTags[objectTag] = |
||||
cloneableTags[regexpTag] = cloneableTags[setTag] = |
||||
cloneableTags[stringTag] = cloneableTags[symbolTag] = |
||||
cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = |
||||
cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true; |
||||
cloneableTags[errorTag] = cloneableTags[funcTag] = |
||||
cloneableTags[weakMapTag] = false; |
||||
|
||||
/** |
||||
* The base implementation of `_.clone` and `_.cloneDeep` which tracks |
||||
* traversed objects. |
||||
* |
||||
* @private |
||||
* @param {*} value The value to clone. |
||||
* @param {boolean} bitmask The bitmask flags. |
||||
* 1 - Deep clone |
||||
* 2 - Flatten inherited properties |
||||
* 4 - Clone symbols |
||||
* @param {Function} [customizer] The function to customize cloning. |
||||
* @param {string} [key] The key of `value`. |
||||
* @param {Object} [object] The parent object of `value`. |
||||
* @param {Object} [stack] Tracks traversed objects and their clone counterparts. |
||||
* @returns {*} Returns the cloned value. |
||||
*/ |
||||
function baseClone(value, bitmask, customizer, key, object, stack) { |
||||
var result, |
||||
isDeep = bitmask & CLONE_DEEP_FLAG, |
||||
isFlat = bitmask & CLONE_FLAT_FLAG, |
||||
isFull = bitmask & CLONE_SYMBOLS_FLAG; |
||||
|
||||
if (customizer) { |
||||
result = object ? customizer(value, key, object, stack) : customizer(value); |
||||
} |
||||
if (result !== undefined) { |
||||
return result; |
||||
} |
||||
if (!isObject(value)) { |
||||
return value; |
||||
} |
||||
var isArr = isArray(value); |
||||
if (isArr) { |
||||
result = initCloneArray(value); |
||||
if (!isDeep) { |
||||
return copyArray(value, result); |
||||
} |
||||
} else { |
||||
var tag = getTag(value), |
||||
isFunc = tag == funcTag || tag == genTag; |
||||
|
||||
if (isBuffer(value)) { |
||||
return cloneBuffer(value, isDeep); |
||||
} |
||||
if (tag == objectTag || tag == argsTag || (isFunc && !object)) { |
||||
result = (isFlat || isFunc) ? {} : initCloneObject(value); |
||||
if (!isDeep) { |
||||
return isFlat |
||||
? copySymbolsIn(value, baseAssignIn(result, value)) |
||||
: copySymbols(value, baseAssign(result, value)); |
||||
} |
||||
} else { |
||||
if (!cloneableTags[tag]) { |
||||
return object ? value : {}; |
||||
} |
||||
result = initCloneByTag(value, tag, isDeep); |
||||
} |
||||
} |
||||
// Check for circular references and return its corresponding clone.
|
||||
stack || (stack = new Stack); |
||||
var stacked = stack.get(value); |
||||
if (stacked) { |
||||
return stacked; |
||||
} |
||||
stack.set(value, result); |
||||
|
||||
if (isSet(value)) { |
||||
value.forEach(function(subValue) { |
||||
result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack)); |
||||
}); |
||||
} else if (isMap(value)) { |
||||
value.forEach(function(subValue, key) { |
||||
result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack)); |
||||
}); |
||||
} |
||||
|
||||
var keysFunc = isFull |
||||
? (isFlat ? getAllKeysIn : getAllKeys) |
||||
: (isFlat ? keysIn : keys); |
||||
|
||||
var props = isArr ? undefined : keysFunc(value); |
||||
arrayEach(props || value, function(subValue, key) { |
||||
if (props) { |
||||
key = subValue; |
||||
subValue = value[key]; |
||||
} |
||||
// Recursively populate clone (susceptible to call stack limits).
|
||||
assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack)); |
||||
}); |
||||
return result; |
||||
} |
||||
|
||||
module.exports = baseClone; |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue