exlim/cyberchef
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into feature/change-to-nginx-unprivileged

Browse Source
This commit is contained in:
GCHQDeveloper581 2026-03-07 10:37:40 +00:00 committed by GitHub
commit 8bf122fe32
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
165 changed files with 16989 additions and 6198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
.cspell.json Normal file
View File

@ -0,0 +1,17 @@
{
"version": "0.2",
"language": "en,en-gb",
"words": [],
"dictionaries": [
"npm",
"softwareTerms",
"node",
"html",
"css",
"bash",
"en-gb",
"misc"
],
"ignorePaths": ["package.json", "package-lock.json", "node_modules"]
}

4
.editorconfig
View File

@ -12,3 +12,7 @@ indent_size = 4
[{package.json,.travis.yml,nightwatch.json}] [{package.json,.travis.yml,nightwatch.json}]
indent_style = space indent_style = space
indent_size = 2 indent_size = 2
[.github/**.yml]
indent_style = space
indent_size = 2

40
.github/workflows/codeql.yml vendored
View File

@ -1,40 +0,0 @@
name: "CodeQL Analysis"
on:
workflow_dispatch:
push:
branches: [ master ]
pull_request:
# The branches below must be a subset of the branches above
branches: [ master ]
types: [synchronize, opened, reopened]
schedule:
- cron: '22 17 * * 5'
jobs:
analyze:
name: Analyze
runs-on: ubuntu-latest
permissions:
actions: read
contents: read
security-events: write
strategy:
fail-fast: false
matrix:
language: [ 'javascript' ]
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Initialize CodeQL
uses: github/codeql-action/init@v2
with:
languages: ${{ matrix.language }}
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v2
with:
category: "/language:${{matrix.language}}"

15
.github/workflows/master.yml vendored
View File

@ -6,16 +6,23 @@ on:
branches: branches:
- master - master
permissions:
contents: read
jobs: jobs:
main: main:
permissions:
contents: write
pages: write
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v6
- name: Set node version - name: Set node version
uses: actions/setup-node@v3 uses: actions/setup-node@v6
with: with:
node-version: '18.x' node-version: 18
registry-url: "https://registry.npmjs.org"
- name: Install - name: Install
run: | run: |
@ -33,7 +40,7 @@ jobs:
- name: Production Build - name: Production Build
if: success() if: success()
run: npx grunt prod --msg="Version 10 is here! Read about the new features <a href='https://github.com/gchq/CyberChef/wiki/Character-encoding,-EOL-separators,-and-editor-features'>here</a>" run: npx grunt prod --msg=""
- name: Generate sitemap - name: Generate sitemap
run: npx grunt exec:sitemap run: npx grunt exec:sitemap

28
.github/workflows/pull_requests.yml vendored
View File

@ -1,5 +1,8 @@
name: "Pull Requests" name: "Pull Requests"
permissions:
contents: read
on: on:
workflow_dispatch: workflow_dispatch:
pull_request: pull_request:
@ -9,12 +12,13 @@ jobs:
main: main:
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v6
- name: Set node version - name: Set node version
uses: actions/setup-node@v3 uses: actions/setup-node@v6
with: with:
node-version: '18.x' node-version: 18
registry-url: "https://registry.npmjs.org"
- name: Install - name: Install
run: | run: |
@ -34,20 +38,18 @@ jobs:
if: success() if: success()
run: npx grunt prod run: npx grunt prod
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Set up QEMU
uses: docker/setup-qemu-action@v3
- name: Production Image Build - name: Production Image Build
if: success() if: success()
id: build-image id: build-image
uses: redhat-actions/buildah-build@v2 uses: docker/build-push-action@v6
with: with:
# Not being uploaded to any registry, use a simple name to allow Buildah to build correctly. platforms: linux/amd64,linux/arm64
image: cyberchef
containerfiles: ./Dockerfile
platforms: linux/amd64
oci: true
# Webpack seems to use a lot of open files, increase the max open file limit to accomodate.
extra-args: |
--ulimit nofile=10000
- name: UI Tests - name: UI Tests
if: success() if: success()
run: | run: |

81
.github/workflows/releases.yml vendored
View File

@ -4,7 +4,10 @@ on:
workflow_dispatch: workflow_dispatch:
push: push:
tags: tags:
- 'v*' - "v*"
permissions:
contents: read
env: env:
REGISTRY: ghcr.io REGISTRY: ghcr.io
@ -14,17 +17,22 @@ env:
jobs: jobs:
main: main:
permissions:
packages: write
contents: write
runs-on: ubuntu-latest runs-on: ubuntu-latest
steps: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v6
- name: Set node version - name: Set node version
uses: actions/setup-node@v3 uses: actions/setup-node@v6
with: with:
node-version: '18.x' node-version: 18
registry-url: "https://registry.npmjs.org"
- name: Install - name: Install
run: | run: |
export DETECT_CHROMEDRIVER_VERSION=true
npm ci npm ci
npm run setheapsize npm run setheapsize
@ -44,6 +52,12 @@ jobs:
sudo apt-get install xvfb sudo apt-get install xvfb
xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Set up QEMU
uses: docker/setup-qemu-action@v3
- name: Image Metadata - name: Image Metadata
id: image-metadata id: image-metadata
uses: docker/metadata-action@v4 uses: docker/metadata-action@v4
@ -54,19 +68,21 @@ jobs:
type=semver,pattern={{major}}.{{minor}} type=semver,pattern={{major}}.{{minor}}
type=semver,pattern={{version}} type=semver,pattern={{version}}
- name: Production Image Build - name: Log in to GHCR
id: build-image uses: docker/login-action@v3
uses: redhat-actions/buildah-build@v2
with: with:
registry: ${{ env.REGISTRY }}
username: ${{ env.REGISTRY_USER }}
password: ${{ env.REGISTRY_PASSWORD }}
- name: Publish to GHCR
uses: docker/build-push-action@v6
with:
context: .
push: true
tags: ${{ steps.image-metadata.outputs.tags }} tags: ${{ steps.image-metadata.outputs.tags }}
labels: ${{ steps.image-metadata.outputs.labels }} labels: ${{ steps.image-metadata.outputs.labels }}
containerfiles: ./Dockerfile platforms: linux/amd64,linux/arm64
platforms: linux/amd64
oci: true
# Webpack seems to use a lot of open files, increase the max open file limit to accomodate.
extra-args: |
--ulimit nofile=10000
- name: Upload Release Assets - name: Upload Release Assets
id: upload-release-assets id: upload-release-assets
@ -79,15 +95,32 @@ jobs:
file_glob: true file_glob: true
body: "See the [CHANGELOG](https://github.com/gchq/CyberChef/blob/master/CHANGELOG.md) and [commit messages](https://github.com/gchq/CyberChef/commits/master) for details." body: "See the [CHANGELOG](https://github.com/gchq/CyberChef/blob/master/CHANGELOG.md) and [commit messages](https://github.com/gchq/CyberChef/commits/master) for details."
- name: Publish to NPM npm-publish:
uses: JS-DevTools/npm-publish@v1 permissions:
with: id-token: write
token: ${{ secrets.NPM_TOKEN }} contents: read
needs: main
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v6
- name: Publish to GHCR - name: Set node version
uses: redhat-actions/push-to-registry@v2 uses: actions/setup-node@v6
with: with:
tags: ${{ steps.build-image.outputs.tags }} node-version: 18
registry: ${{ env.REGISTRY }} registry-url: "https://registry.npmjs.org"
username: ${{ env.REGISTRY_USER }}
password: ${{ env.REGISTRY_PASSWORD }} - name: Install
run: npm ci
- name: Create machine generated files
run: npm run node
- name: Reset node version ready for publish
uses: actions/setup-node@v6
with:
node-version: ^24.5
registry-url: "https://registry.npmjs.org"
- name: Publish to NPM
run: npm publish

232
CHANGELOG.md
View File

@ -13,6 +13,104 @@ All major and minor version changes will be documented in this file. Details of
## Details ## Details
### [10.22.0] - 2026-02-11
- Separate npm publish out into separate job and run with Node 24.5 [@GCHQDeveloper581] | [#2188]
- Fixed Percent delimiter for hex encoding [@beneri] [@C85297] | [#2137]
- Added the ability to paste one or more Images from the Clipboard [@t-martine] [@a3957273] [@C85297] | [#1876]
- Quoted Printable - consistent reference to 'email' [@wesinator] | [#2186]
- Fix freeze when output text decoding fails [@Raka-loah] | [#1573]
- Update Browserslist DB [@C85297] | [#2183]
- Add contents write permission to releases workflow [@C85297] | [#2182]
- Fix release workflow permissions [@C85297] | [#2181]
### [10.21.0] - 2026-02-05
- Fix import operations with special chars in them [@d98762625] [@jg42526] | [#1040]
- Remove custom CodeQL workflow [@C85297] | [#2176]
- Fix code scanning warnings in workflows [@GCHQDeveloper581] | [#2177]
- Use NPM trusted publishing [@C85297] [@GCHQDeveloper581] | [#2174]
- Fix: Correctly parse xxd odd byte hexdumps [@ThomasNotTom] [@GCHQDeveloper581] | [#2058]
- Update Sitemap URLs to Use Valid Paths in sitemap.mjs [@rbpi] [@C85297] | [#1861]
- Use recommended GitHub Actions to build image [@AlexGustafsson] [@C85297] | [#2055]
- Remove version 10 message from banner [@C85297] | [#2169]
- Bump form-data from 4.0.1 to 4.0.5 | [#2175]
- Bump node-forge from 1.3.1 to 1.3.3 | [#2173]
- Update crypto browserify [@C85297] | [#2172]
- Update kbpgp package (resolves #2135) [@GCHQDeveloper581] | [#2136]
- Fix the processing of ALPNs for JA4 to align with new specification update [@tuliperis] | [#2165]
- Add Bech32 and Bech32m encoding/decoding operations [@thomasxm] | [#2159]
- Exclude Delete character from hex dump output [@mikecat] [@C85297] | [#2086]
- Tiny typo fix in "To Base85" operation [@twostraws] | [#2118]
- Bump jsonpath-plus [@C85297] | [#2166]
### [10.20.0] - 2026-01-28
- Fixed Optical Character Recognition and added tests [@n1474335] | [ab37c1e]
- Fixed JA4 version fallback value [@n1474335] | [7a5225c]
- Updated chromedriver [@n1474335] | [0e82e4b]
- Fixed RSA Sign and Verify character encodings [@n1474335] | [895a929]
- Updated chromedriver [@n1474335] | [d3adfc7]
- Added message format arg to RSA Verify operation [@n1474335] | [47c85a1]
- Add operation for parsing X.509 CRLs [@robinsandhu] | [#1887]
- Fix typo in description of JWT Sign recipe [@GuilhermoReadonly] | [#1961]
- Corrected path to generateNodeIndex.mjs [@simonarnell] | [#1959]
- Add 'header' ingredient to JWT Sign operation [@RandomByte] | [#1957]
- Add Parse TLS record operation [@c65722] | [#1936]
- Automatically detect chrome driver version [@gchq] | [#1972]
- Add Strip UDP header operation [@c65722] | [#1900]
- Add Strip TCP header operation [@c65722] | [#1898]
- Webpack compress with gzip and brotli [@max0x53] | [#1955]
- add offset field to 'Add Line Numbers' operation [@Adamkadaban] | [#1866]
- Disable flakey URL test [@a3957273] | [#1973]
- Add Strip IPv4 header operation [@c65722] | [#1899]
- IPv6 Transition Operation [@jb30795] | [#1780]
- fix: Blowfish - ignore IV length in ECB mode [@FranciscoPombal] | [#1902]
- Add 'Drop nth bytes' operation [@Oshawk] | [#1914]
- Add 'Take nth bytes' operation [@Oshawk] | [#1915]
- Add Leet Speak [@bartblaze] | [#1971]
- Fix Generate TOTP & HOPT [@exactlyaron] | [#1966]
- Updated luhn checksum operation to work with different bases [@k3ach] | [#1933]
- automatically theme mode based on user preference [@vs4vijay] | [#1921]
- fix: DES/Triple DES - misleading error messages [@FranciscoPombal] | [#1904]
- fix: ROT13 - shifting numbers by negative amounts [@FranciscoPombal] | [#1903]
- Introduce Yubico's Modhex for Conversion [@linuxgemini] | [#1105]
- Feature: MIME RFC2047 Decoding [@MShwed] | [#630]
- CC-1889 add _ option [@depperm] | [#1977]
- chore(root): add cspell [@evenstensberg] | [#1976]
- Preserve uppercase for Leet Speak [@bartblaze] | [#1981]
- Load the user's preferred color scheme if the URL contains an invalid theme [@0xh3xa] | [#2007]
- Add SM2 Encrypt and Decrypt Operations [@flakjacket95] | [#1909]
- Support jq as an operation. [@zhzy0077] | [#1604]
- Add fingerprints to the 'Parse X.509 certificate' operation [@JSCU-CNI] | [#1863]
- Added a JSON to YAML and a YAML to JSON operation [@ccarpo] | [#1286]
- Add CRC Operation [@r4mos] | [#1993]
- Bug Fix: selected theme not loading when refreshing [@0xh3xa] | [#2006]
- Fix(RecipeWaiter): sanitize user input in addOperation to prevent XSS [@0xh3xa] | [#2014]
- Docker multiplatform build support [@PathToLife] | [#1974]
- Add Base32 Hex Extended Alphabet and Base32 Tests. [@peterc-s] | [#1991]
- Add ECB/NoPadding and CBC/NoPadding support to AES encryption [@plvie] | [#2013]
- Add new operation: PHP Serialize [@brun0ne] | [#1548]
- Push input through postmessage [@kenduguay1] | [#1992]
- Add jsonata query operation [@jonking-ajar] | [#1587]
- Re-enable Npm Release in github workflows [@PathToLife] | [#2031]
- Add to ECDSA Verify the message format [@r4mos] | [#2027]
- Added alternating caps functionality [@sw5678] | [#1897]
- XOR Checksum operation added [@jg42526] | [#2035]
- Add GenerateAllChecksums operation * Remove checksums from GenerateAllHashes operation [@es45411] | [66d445c]
- Update GenerateAllChecksums infoURL [@es45411] | [#2037]
- Add toggle "+" character to URLDecode operation [@es45411] | [#2040]
- Workaround for Safari load bug [@GCHQDeveloper94872] | [#2038]
- Updated Dockerfile to correctly build on ARM64 platforms [@Sma-Das] | [#2042]
- Addresses bug report #2008 Added explicit support for octal IP addresses. Changed approach to IPv4 regex to be string manipulation generated. Added some unit tests for IP address parsing - probably not full coverage. Added lookahead and lookbehind tricks to resolve warned issue that 1.2.3.256 would still be extracted as 1.2.3.25. Now only accepts valid IP addresses. Warning replaced with clause about infinite length dotted decimal forms. [@gchqdev364] | [#2041]
- Remove trim from rail fence [@Odyhibit] | [#1986]
- Fix email regex [@ericli-splunk] | [#2025]
- Add Blake3 hashing [@xumptex] | [#2023]
- Use defaultIndex instead of 0 in transformArgs [@bartvanandel] | [#2015]
- Add "Generate UUID" and "Analyse UUID" operations [@bartvanandel] | [#2011]
- Add new operation: Template [@kendallgoto] | [#2021]
- Add more clear build instructions [@remingtr] | [#1873]
- Show On Map updated to use leaflet over WikiMedia [@0xff1ce] | [#1884]
- Fixed ToDecimal signed logic [@starplanet] | [#1545]
- Use BigInt for encoding/decoding VarInt [@mikecat] | [#1978]
### [10.19.0] - 2024-06-21 ### [10.19.0] - 2024-06-21
- Add support for ECDSA and DSA in 'Parse CSR' [@robinsandhu] | [#1828] - Add support for ECDSA and DSA in 'Parse CSR' [@robinsandhu] | [#1828]
- Fix typos in SIGABA.mjs [@eltociear] | [#1834] - Fix typos in SIGABA.mjs [@eltociear] | [#1834]
@ -440,6 +538,9 @@ All major and minor version changes will be documented in this file. Details of
## [4.0.0] - 2016-11-28 ## [4.0.0] - 2016-11-28
- Initial open source commit [@n1474335] | [b1d73a72](https://github.com/gchq/CyberChef/commit/b1d73a725dc7ab9fb7eb789296efd2b7e4b08306) - Initial open source commit [@n1474335] | [b1d73a72](https://github.com/gchq/CyberChef/commit/b1d73a725dc7ab9fb7eb789296efd2b7e4b08306)
[10.22.0]: https://github.com/gchq/CyberChef/releases/tag/v10.22.0
[10.21.0]: https://github.com/gchq/CyberChef/releases/tag/v10.21.0
[10.20.0]: https://github.com/gchq/CyberChef/releases/tag/v10.20.0
[10.19.0]: https://github.com/gchq/CyberChef/releases/tag/v10.19.0 [10.19.0]: https://github.com/gchq/CyberChef/releases/tag/v10.19.0
[10.18.0]: https://github.com/gchq/CyberChef/releases/tag/v10.18.0 [10.18.0]: https://github.com/gchq/CyberChef/releases/tag/v10.18.0
[10.17.0]: https://github.com/gchq/CyberChef/releases/tag/v10.17.0 [10.17.0]: https://github.com/gchq/CyberChef/releases/tag/v10.17.0
@ -630,6 +731,72 @@ All major and minor version changes will be documented in this file. Details of
[@cplussharp]: https://github.com/cplussharp [@cplussharp]: https://github.com/cplussharp
[@robinsandhu]: https://github.com/robinsandhu [@robinsandhu]: https://github.com/robinsandhu
[@eltociear]: https://github.com/eltociear [@eltociear]: https://github.com/eltociear
[@GuilhermoReadonly]: https://github.com/GuilhermoReadonly
[@simonarnell]: https://github.com/simonarnell
[@RandomByte]: https://github.com/RandomByte
[@c65722]: https://github.com/c65722
[@c65722]: https://github.com/c65722
[@c65722]: https://github.com/c65722
[@max0x53]: https://github.com/max0x53
[@Adamkadaban]: https://github.com/Adamkadaban
[@c65722]: https://github.com/c65722
[@jb30795]: https://github.com/jb30795
[@FranciscoPombal]: https://github.com/FranciscoPombal
[@Oshawk]: https://github.com/Oshawk
[@Oshawk]: https://github.com/Oshawk
[@bartblaze]: https://github.com/bartblaze
[@exactlyaron]: https://github.com/exactlyaron
[@k3ach]: https://github.com/k3ach
[@vs4vijay]: https://github.com/vs4vijay
[@FranciscoPombal]: https://github.com/FranciscoPombal
[@FranciscoPombal]: https://github.com/FranciscoPombal
[@linuxgemini]: https://github.com/linuxgemini
[@depperm]: https://github.com/depperm
[@evenstensberg]: https://github.com/evenstensberg
[@bartblaze]: https://github.com/bartblaze
[@0xh3xa]: https://github.com/0xh3xa
[@flakjacket95]: https://github.com/flakjacket95
[@zhzy0077]: https://github.com/zhzy0077
[@JSCU-CNI]: https://github.com/JSCU-CNI
[@ccarpo]: https://github.com/ccarpo
[@r4mos]: https://github.com/r4mos
[@0xh3xa]: https://github.com/0xh3xa
[@0xh3xa]: https://github.com/0xh3xa
[@PathToLife]: https://github.com/PathToLife
[@peterc-s]: https://github.com/peterc-s
[@plvie]: https://github.com/plvie
[@kenduguay1]: https://github.com/kenduguay1
[@jonking-ajar]: https://github.com/jonking-ajar
[@PathToLife]: https://github.com/PathToLife
[@r4mos]: https://github.com/r4mos
[@jg42526]: https://github.com/jg42526
[@es45411]: https://github.com/es45411
[@gchq]: https://github.com/gchq
[@gchqdev364]: https://github.com/gchqdev364
[@GCHQDeveloper94872]: https://github.com/GCHQDeveloper94872
[@Sma-Das]: https://github.com/Sma-Das
[@gchq]: https://github.com/gchq
[@Odyhibit]: https://github.com/Odyhibit
[@ericli-splunk]: https://github.com/ericli-splunk
[@xumptex]: https://github.com/xumptex
[@bartvanandel]: https://github.com/bartvanandel
[@bartvanandel]: https://github.com/bartvanandel
[@kendallgoto]: https://github.com/kendallgoto
[@remingtr]: https://github.com/remingtr
[@0xff1ce]: https://github.com/0xff1ce
[@starplanet]: https://github.com/starplanet
[@C85297]: https://github.com/C85297
[@GCHQDeveloper581]: https://github.com/GCHQDeveloper581
[@ThomasNotTom]: https://github.com/ThomasNotTom
[@rbpi]: https://github.com/rbpi
[@AlexGustafsson]: https://github.com/AlexGustafsson
[@tuliperis]: https://github.com/tuliperis
[@thomasxm]: https://github.com/thomasxm
[@twostraws]: https://github.com/twostraws
[@beneri]: https://github.com/beneri
[@t-martine]: https://github.com/t-martine
[@wesinator]: https://github.com/wesinator
[@Raka-loah]: https://github.com/Raka-loah
[8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7 [8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
@ -642,6 +809,46 @@ All major and minor version changes will be documented in this file. Details of
[760eff4]: https://github.com/gchq/CyberChef/commit/760eff49b5307aaa3104c5e5b437ffe62299acd1 [760eff4]: https://github.com/gchq/CyberChef/commit/760eff49b5307aaa3104c5e5b437ffe62299acd1
[65ffd8d]: https://github.com/gchq/CyberChef/commit/65ffd8d65d88eb369f6f61a5d1d0f807179bffb7 [65ffd8d]: https://github.com/gchq/CyberChef/commit/65ffd8d65d88eb369f6f61a5d1d0f807179bffb7
[0a353ee]: https://github.com/gchq/CyberChef/commit/0a353eeb378b9ca5d49e23c7dfc175ae07107b08 [0a353ee]: https://github.com/gchq/CyberChef/commit/0a353eeb378b9ca5d49e23c7dfc175ae07107b08
[66d445c]: https://github.com/gchq/CyberChef/commit/66d445c5ef4e8bd896fd15396e3ce2d660d8ace1
[ab37c1e]: https://github.com/gchq/CyberChef/commit/ab37c1e562dbee0495ed32876ecbb8225282af25
[965570d]: https://github.com/gchq/CyberChef/commit/965570d2504c17ee1f96211a1dc10ed40cd2b332
[a477f47]: https://github.com/gchq/CyberChef/commit/a477f47aecd01d78b11fe186ed4b20d9c487cfac
[7a5225c]: https://github.com/gchq/CyberChef/commit/7a5225c961a5e0d192b03152117cd10a761f73d6
[5f88ae4]: https://github.com/gchq/CyberChef/commit/5f88ae44ec77228d9bed8f11e8cc8e7dcfb36914
[0e82e4b]: https://github.com/gchq/CyberChef/commit/0e82e4b7c6c77cadb8be61cb145e081d6ecfdc88
[d635cca]: https://github.com/gchq/CyberChef/commit/d635cca2106aae2a59caf0e5d7e3633ee1ea3155
[895a929]: https://github.com/gchq/CyberChef/commit/895a9299255525cb57886deb9d9fd4ba17ae9548
[270a333]: https://github.com/gchq/CyberChef/commit/270a33317944612d27ea1cc15275ad6b0ed097e5
[d3adfc7]: https://github.com/gchq/CyberChef/commit/d3adfc7c3e5719279524356bce5261bd8350c0f8
[47c85a1]: https://github.com/gchq/CyberChef/commit/47c85a105ddbdd4cabfa44ddddbc56e3907a8c33
[3822c6c]: https://github.com/gchq/CyberChef/commit/3822c6c520a0b4200abc675c33f46082f5b9efc6
[66d445c]: https://github.com/gchq/CyberChef/commit/66d445c5ef4e8bd896fd15396e3ce2d660d8ace1
[ab37c1e]: https://github.com/gchq/CyberChef/commit/ab37c1e562dbee0495ed32876ecbb8225282af25
[965570d]: https://github.com/gchq/CyberChef/commit/965570d2504c17ee1f96211a1dc10ed40cd2b332
[a477f47]: https://github.com/gchq/CyberChef/commit/a477f47aecd01d78b11fe186ed4b20d9c487cfac
[7a5225c]: https://github.com/gchq/CyberChef/commit/7a5225c961a5e0d192b03152117cd10a761f73d6
[5f88ae4]: https://github.com/gchq/CyberChef/commit/5f88ae44ec77228d9bed8f11e8cc8e7dcfb36914
[0e82e4b]: https://github.com/gchq/CyberChef/commit/0e82e4b7c6c77cadb8be61cb145e081d6ecfdc88
[d635cca]: https://github.com/gchq/CyberChef/commit/d635cca2106aae2a59caf0e5d7e3633ee1ea3155
[895a929]: https://github.com/gchq/CyberChef/commit/895a9299255525cb57886deb9d9fd4ba17ae9548
[270a333]: https://github.com/gchq/CyberChef/commit/270a33317944612d27ea1cc15275ad6b0ed097e5
[d3adfc7]: https://github.com/gchq/CyberChef/commit/d3adfc7c3e5719279524356bce5261bd8350c0f8
[47c85a1]: https://github.com/gchq/CyberChef/commit/47c85a105ddbdd4cabfa44ddddbc56e3907a8c33
[3822c6c]: https://github.com/gchq/CyberChef/commit/3822c6c520a0b4200abc675c33f46082f5b9efc6
[66d445c]: https://github.com/gchq/CyberChef/commit/66d445c5ef4e8bd896fd15396e3ce2d660d8ace1
[ab37c1e]: https://github.com/gchq/CyberChef/commit/ab37c1e562dbee0495ed32876ecbb8225282af25
[965570d]: https://github.com/gchq/CyberChef/commit/965570d2504c17ee1f96211a1dc10ed40cd2b332
[a477f47]: https://github.com/gchq/CyberChef/commit/a477f47aecd01d78b11fe186ed4b20d9c487cfac
[7a5225c]: https://github.com/gchq/CyberChef/commit/7a5225c961a5e0d192b03152117cd10a761f73d6
[5f88ae4]: https://github.com/gchq/CyberChef/commit/5f88ae44ec77228d9bed8f11e8cc8e7dcfb36914
[0e82e4b]: https://github.com/gchq/CyberChef/commit/0e82e4b7c6c77cadb8be61cb145e081d6ecfdc88
[d635cca]: https://github.com/gchq/CyberChef/commit/d635cca2106aae2a59caf0e5d7e3633ee1ea3155
[895a929]: https://github.com/gchq/CyberChef/commit/895a9299255525cb57886deb9d9fd4ba17ae9548
[270a333]: https://github.com/gchq/CyberChef/commit/270a33317944612d27ea1cc15275ad6b0ed097e5
[d3adfc7]: https://github.com/gchq/CyberChef/commit/d3adfc7c3e5719279524356bce5261bd8350c0f8
[47c85a1]: https://github.com/gchq/CyberChef/commit/47c85a105ddbdd4cabfa44ddddbc56e3907a8c33
[3822c6c]: https://github.com/gchq/CyberChef/commit/3822c6c520a0b4200abc675c33f46082f5b9efc6
[66d445c]: https://github.com/gchq/CyberChef/commit/66d445c5ef4e8bd896fd15396e3ce2d660d8ace1
[#95]: https://github.com/gchq/CyberChef/pull/299 [#95]: https://github.com/gchq/CyberChef/pull/299
[#173]: https://github.com/gchq/CyberChef/pull/173 [#173]: https://github.com/gchq/CyberChef/pull/173
@ -778,4 +985,29 @@ All major and minor version changes will be documented in this file. Details of
[#512]: https://github.com/gchq/CyberChef/issues/512 [#512]: https://github.com/gchq/CyberChef/issues/512
[#1732]: https://github.com/gchq/CyberChef/issues/1732 [#1732]: https://github.com/gchq/CyberChef/issues/1732
[#1789]: https://github.com/gchq/CyberChef/issues/1789 [#1789]: https://github.com/gchq/CyberChef/issues/1789
[#1040]: https://github.com/gchq/CyberChef/pull/1040
[#2176]: https://github.com/gchq/CyberChef/pull/2176
[#2177]: https://github.com/gchq/CyberChef/pull/2177
[#2174]: https://github.com/gchq/CyberChef/pull/2174
[#2058]: https://github.com/gchq/CyberChef/pull/2058
[#1861]: https://github.com/gchq/CyberChef/pull/1861
[#2055]: https://github.com/gchq/CyberChef/pull/2055
[#2169]: https://github.com/gchq/CyberChef/pull/2169
[#2175]: https://github.com/gchq/CyberChef/pull/2175
[#2173]: https://github.com/gchq/CyberChef/pull/2173
[#2172]: https://github.com/gchq/CyberChef/pull/2172
[#2136]: https://github.com/gchq/CyberChef/pull/2136
[#2165]: https://github.com/gchq/CyberChef/pull/2165
[#2159]: https://github.com/gchq/CyberChef/pull/2159
[#2086]: https://github.com/gchq/CyberChef/pull/2086
[#2118]: https://github.com/gchq/CyberChef/pull/2118
[#2166]: https://github.com/gchq/CyberChef/pull/2166
[#2188]: https://github.com/gchq/CyberChef/pull/2188
[#2137]: https://github.com/gchq/CyberChef/pull/2137
[#1876]: https://github.com/gchq/CyberChef/pull/1876
[#2186]: https://github.com/gchq/CyberChef/pull/2186
[#1573]: https://github.com/gchq/CyberChef/pull/1573
[#2183]: https://github.com/gchq/CyberChef/pull/2183
[#2182]: https://github.com/gchq/CyberChef/pull/2182
[#2181]: https://github.com/gchq/CyberChef/pull/2181

33
Dockerfile
View File

@ -1,9 +1,34 @@
FROM node:18-alpine AS build #####################################
# Build the app to a static website #
#####################################
# Modifier --platform=$BUILDPLATFORM limits the platform to "BUILDPLATFORM" during buildx multi-platform builds
# This is because npm "chromedriver" package is not compatiable with all platforms
# For more info see: https://docs.docker.com/build/building/multi-platform/#cross-compilation
FROM --platform=$BUILDPLATFORM node:18-alpine AS builder
WORKDIR /app
COPY package.json .
COPY package-lock.json .
# Install dependencies
# --ignore-scripts prevents postinstall script (which runs grunt) as it depends on files other than package.json
RUN npm ci --ignore-scripts
# Copy files needed for postinstall and build
COPY . . COPY . .
RUN npm ci
# npm postinstall runs grunt, which depends on files other than package.json
RUN npm run postinstall
# Build the app
RUN npm run build RUN npm run build
FROM nginxinc/nginx-unprivileged:1.25.1-alpine3.18 AS cyberchef #########################################
# Package static build files into nginx #
#########################################
FROM nginxinc/nginx-unprivileged:stable-alpine AS cyberchef
COPY --from=build ./build/prod /usr/share/nginx/html/ LABEL maintainer="GCHQ <oss@gchq.gov.uk>"
COPY --from=builder /app/build/prod /usr/share/nginx/html/

12
Gruntfile.js
View File

@ -432,18 +432,6 @@ module.exports = function (grunt) {
}, },
stdout: false stdout: false
}, },
fixJimpModule: {
command: function () {
switch (process.platform) {
case "darwin":
// Space added before comma to prevent multiple modifications
return `sed -i '' 's/"es\\/index.js",/"es\\/index.js" ,\\n "type": "module",/' ./node_modules/jimp/package.json`;
default:
return `sed -i 's/"es\\/index.js",/"es\\/index.js" ,\\n "type": "module",/' ./node_modules/jimp/package.json`;
}
},
stdout: false
}
}, },
}); });
}; };

21
README.md
View File

@ -20,21 +20,36 @@ Cryptographic operations in CyberChef should not be relied upon to provide secur
[A live demo can be found here][1] - have fun! [A live demo can be found here][1] - have fun!
## Containers ## Running Locally with Docker
If you would like to try out CyberChef locally you can either build it yourself: **Prerequisites**
- [Docker](hhttps://www.docker.com/products/docker-desktop/)
- Docker Desktop must be open and running on your machine
#### Option 1: Build the Docker Image Yourself
1. Build the docker image
```bash ```bash
docker build --tag cyberchef --ulimit nofile=10000 . docker build --tag cyberchef --ulimit nofile=10000 .
```
2. Run the docker container
```bash
docker run -it -p 8080:8080 cyberchef docker run -it -p 8080:8080 cyberchef
``` ```
3. Navigate to `http://localhost:8080` in your browser
Or you can use our image directly: #### Option 2: Use the pre-built Docker Image
If you prefer to skip the build process, you can use the pre-built image
```bash ```bash
docker run -it -p 8080:8080 ghcr.io/gchq/cyberchef:latest docker run -it -p 8080:8080 ghcr.io/gchq/cyberchef:latest
``` ```
Just like before, navigate to `http://localhost:8080` in your browser.
This image is built and published through our [GitHub Workflows](.github/workflows/releases.yml) This image is built and published through our [GitHub Workflows](.github/workflows/releases.yml)
## How it works ## How it works

6
babel.config.js
View File

@ -10,13 +10,7 @@ module.exports = function(api) {
}] }]
], ],
"plugins": [ "plugins": [
"dynamic-import-node",
"@babel/plugin-syntax-import-assertions", "@babel/plugin-syntax-import-assertions",
[
"babel-plugin-transform-builtin-extend", {
"globals": ["Error"]
}
],
[ [
"@babel/plugin-transform-runtime", { "@babel/plugin-transform-runtime", {
"regenerator": true "regenerator": true

5866
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

130
package.json
View File

@ -1,6 +1,6 @@
{ {
"name": "cyberchef", "name": "cyberchef",
"version": "10.19.4", "version": "10.22.1",
"description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.", "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
"author": "n1474335 <n1474335@gmail.com>", "author": "n1474335 <n1474335@gmail.com>",
"homepage": "https://gchq.github.io/CyberChef", "homepage": "https://gchq.github.io/CyberChef",
@ -39,56 +39,54 @@
"node >= 16" "node >= 16"
], ],
"devDependencies": { "devDependencies": {
"@babel/core": "^7.24.7", "@babel/eslint-parser": "^7.28.6",
"@babel/eslint-parser": "^7.24.7", "@babel/plugin-syntax-import-assertions": "^7.28.6",
"@babel/plugin-syntax-import-assertions": "^7.24.7", "@babel/plugin-transform-runtime": "^7.29.0",
"@babel/plugin-transform-runtime": "^7.24.7", "@babel/preset-env": "^7.29.0",
"@babel/preset-env": "^7.24.7", "@babel/runtime": "^7.28.6",
"@babel/runtime": "^7.24.7", "@codemirror/commands": "^6.10.2",
"@codemirror/commands": "^6.6.0", "@codemirror/language": "^6.12.1",
"@codemirror/language": "^6.10.2", "@codemirror/search": "^6.6.0",
"@codemirror/search": "^6.5.6", "@codemirror/state": "^6.5.4",
"@codemirror/state": "^6.4.1", "@codemirror/view": "^6.39.15",
"@codemirror/view": "^6.28.0", "autoprefixer": "^10.4.24",
"autoprefixer": "^10.4.19", "babel-loader": "^10.0.0",
"babel-loader": "^9.1.3",
"babel-plugin-dynamic-import-node": "^2.3.3",
"babel-plugin-transform-builtin-extend": "1.1.2",
"base64-loader": "^1.0.0", "base64-loader": "^1.0.0",
"chromedriver": "^130.0.0", "chromedriver": "^130.0.4",
"cli-progress": "^3.12.0", "cli-progress": "^3.12.0",
"colors": "^1.4.0", "colors": "^1.4.0",
"compression-webpack-plugin": "^11.1.0", "compression-webpack-plugin": "^11.1.0",
"copy-webpack-plugin": "^12.0.2", "copy-webpack-plugin": "^13.0.1",
"core-js": "^3.37.1", "core-js": "^3.48.0",
"css-loader": "7.1.2", "cspell": "^8.19.4",
"eslint": "^9.4.0", "css-loader": "7.1.4",
"eslint-plugin-jsdoc": "^48.2.9", "eslint": "^9.39.3",
"globals": "^15.4.0", "eslint-plugin-jsdoc": "^50.8.0",
"globals": "^15.15.0",
"grunt": "^1.6.1", "grunt": "^1.6.1",
"grunt-chmod": "~1.1.1", "grunt-chmod": "~1.1.1",
"grunt-concurrent": "^3.0.0", "grunt-concurrent": "^3.0.0",
"grunt-contrib-clean": "~2.0.1", "grunt-contrib-clean": "~2.0.1",
"grunt-contrib-connect": "^4.0.0", "grunt-contrib-connect": "^5.0.1",
"grunt-contrib-copy": "~1.0.0", "grunt-contrib-copy": "~1.0.0",
"grunt-contrib-watch": "^1.1.0", "grunt-contrib-watch": "^1.1.0",
"grunt-eslint": "^25.0.0", "grunt-eslint": "^25.0.0",
"grunt-exec": "~3.0.0", "grunt-exec": "~3.0.0",
"grunt-webpack": "^6.0.0", "grunt-webpack": "^6.0.0",
"grunt-zip": "^1.0.0", "grunt-zip": "^1.0.0",
"html-webpack-plugin": "^5.6.0", "html-webpack-plugin": "^5.6.6",
"imports-loader": "^5.0.0", "imports-loader": "^5.0.0",
"mini-css-extract-plugin": "2.9.0", "mini-css-extract-plugin": "2.10.0",
"modify-source-webpack-plugin": "^4.1.0", "modify-source-webpack-plugin": "^4.1.0",
"nightwatch": "^3.6.3", "nightwatch": "^3.15.0",
"postcss": "^8.4.38", "postcss": "^8.5.6",
"postcss-css-variables": "^0.19.0", "postcss-css-variables": "^0.19.0",
"postcss-import": "^16.1.0", "postcss-import": "^16.1.1",
"postcss-loader": "^8.1.1", "postcss-loader": "^8.2.1",
"prompt": "^1.3.0", "prompt": "^1.3.0",
"sitemap": "^8.0.0", "sitemap": "^8.0.2",
"terser": "^5.31.1", "terser": "^5.46.0",
"webpack": "^5.91.0", "webpack": "^5.105.2",
"webpack-bundle-analyzer": "^4.10.2", "webpack-bundle-analyzer": "^4.10.2",
"webpack-dev-server": "5.0.4", "webpack-dev-server": "5.0.4",
"webpack-node-externals": "^3.0.0", "webpack-node-externals": "^3.0.0",
@ -96,15 +94,15 @@
}, },
"dependencies": { "dependencies": {
"@astronautlabs/amf": "^0.0.6", "@astronautlabs/amf": "^0.0.6",
"@babel/polyfill": "^7.12.1",
"@blu3r4y/lzma": "^2.3.3", "@blu3r4y/lzma": "^2.3.3",
"@wavesenterprise/crypto-gost-js": "^2.1.0-RC1", "@wavesenterprise/crypto-gost-js": "^2.1.0-RC1",
"@xmldom/xmldom": "^0.8.10", "@xmldom/xmldom": "^0.8.11",
"argon2-browser": "^1.18.0", "argon2-browser": "^1.18.0",
"arrive": "^2.4.1", "arrive": "^2.5.2",
"avsc": "^5.7.7", "assert": "^2.1.0",
"avsc": "^5.7.9",
"bcryptjs": "^2.4.3", "bcryptjs": "^2.4.3",
"bignumber.js": "^9.1.2", "bignumber.js": "^9.3.1",
"blakejs": "^1.2.1", "blakejs": "^1.2.1",
"bootstrap": "4.6.2", "bootstrap": "4.6.2",
"bootstrap-colorpicker": "^3.4.0", "bootstrap-colorpicker": "^3.4.0",
@ -116,45 +114,50 @@
"chi-squared": "^1.1.0", "chi-squared": "^1.1.0",
"codepage": "^1.15.0", "codepage": "^1.15.0",
"crypto-api": "^0.8.5", "crypto-api": "^0.8.5",
"crypto-browserify": "^3.12.0", "crypto-browserify": "^3.12.1",
"crypto-js": "^4.2.0", "crypto-js": "^4.2.0",
"ctph.js": "0.0.5", "ctph.js": "0.0.5",
"d3": "7.9.0", "d3": "7.9.0",
"d3-hexbin": "^0.2.2", "d3-hexbin": "^0.2.2",
"diff": "^5.2.0", "diff": "^5.2.2",
"dompurify": "^3.3.1",
"es6-promisify": "^7.0.0", "es6-promisify": "^7.0.0",
"escodegen": "^2.1.0", "escodegen": "^2.1.0",
"esprima": "^4.0.1", "esprima": "^4.0.1",
"events": "^3.3.0",
"exif-parser": "^0.1.12", "exif-parser": "^0.1.12",
"fernet": "^0.4.0", "fernet": "^0.3.3",
"file-saver": "^2.0.5", "file-saver": "^2.0.5",
"flat": "^6.0.1", "flat": "^6.0.1",
"geodesy": "1.1.3", "geodesy": "1.1.3",
"highlight.js": "^11.9.0", "handlebars": "^4.7.8",
"hash-wasm": "^4.12.0",
"highlight.js": "^11.11.1",
"ieee754": "^1.2.1", "ieee754": "^1.2.1",
"jimp": "^0.22.12", "jimp": "^1.6.0",
"jq-wasm": "^1.1.0-jq-1.8.1",
"jquery": "3.7.1", "jquery": "3.7.1",
"js-crc": "^0.2.0",
"js-sha3": "^0.9.3", "js-sha3": "^0.9.3",
"jsesc": "^3.0.2", "jsesc": "^3.1.0",
"json5": "^2.2.3", "json5": "^2.2.3",
"jsonpath-plus": "^9.0.0", "jsonata": "^2.1.0",
"jsonwebtoken": "8.5.1", "jsonpath-plus": "^10.4.0",
"jsonwebtoken": "9.0.0",
"jsqr": "^1.4.0", "jsqr": "^1.4.0",
"jsrsasign": "^11.1.0", "jsrsasign": "^11.1.1",
"kbpgp": "2.1.15", "kbpgp": "^2.1.17",
"libbzip2-wasm": "0.0.4", "libbzip2-wasm": "0.0.4",
"libyara-wasm": "^1.2.1", "libyara-wasm": "^1.2.1",
"lodash": "^4.17.21", "lodash": "^4.17.23",
"loglevel": "^1.9.1", "loglevel": "^1.9.2",
"loglevel-message-prefix": "^3.0.0", "loglevel-message-prefix": "^3.0.0",
"lz-string": "^1.5.0", "lz-string": "^1.5.0",
"lz4js": "^0.2.0", "lz4js": "^0.2.0",
"markdown-it": "^14.1.0", "markdown-it": "^14.1.1",
"moment": "^2.30.1", "moment": "^2.30.1",
"moment-timezone": "^0.5.45", "moment-timezone": "^0.6.0",
"ngeohash": "^0.6.3", "ngeohash": "^0.6.3",
"node-forge": "^1.3.1", "node-forge": "^1.3.3",
"node-md6": "^0.1.0", "node-md6": "^0.1.0",
"nodom": "^2.4.0", "nodom": "^2.4.0",
"notepack.io": "^3.0.1", "notepack.io": "^3.0.1",
@ -164,23 +167,26 @@
"path": "^0.12.7", "path": "^0.12.7",
"popper.js": "^1.16.1", "popper.js": "^1.16.1",
"process": "^0.11.10", "process": "^0.11.10",
"protobufjs": "^7.3.1", "protobufjs": "^7.5.4",
"qr-image": "^3.2.0", "qr-image": "^3.2.0",
"reflect-metadata": "^0.2.2", "reflect-metadata": "^0.2.2",
"rison": "^0.1.1", "rison": "^0.1.1",
"scryptsy": "^2.1.0", "scryptsy": "^2.1.0",
"snackbarjs": "^1.1.0", "snackbarjs": "^1.1.0",
"sortablejs": "^1.15.2", "sortablejs": "^1.15.7",
"split.js": "^1.6.5", "split.js": "^1.6.5",
"sql-formatter": "^15.6.5",
"ssdeep.js": "0.0.3", "ssdeep.js": "0.0.3",
"stream-browserify": "^3.0.0", "stream-browserify": "^3.0.0",
"tesseract.js": "5.1.0", "tesseract.js": "^6.0.1",
"ua-parser-js": "^1.0.38", "ua-parser-js": "^1.0.41",
"unorm": "^1.6.0", "unorm": "^1.6.0",
"url": "^0.11.4",
"utf8": "^3.0.0", "utf8": "^3.0.0",
"uuid": "^13.0.0",
"vkbeautify": "^0.99.3", "vkbeautify": "^0.99.3",
"xpath": "0.0.34", "xpath": "0.0.34",
"xregexp": "^5.1.1", "xregexp": "^5.1.2",
"zlibjs": "^0.3.1" "zlibjs": "^0.3.1"
}, },
"scripts": { "scripts": {
@ -193,9 +199,11 @@
"testui": "npx grunt testui", "testui": "npx grunt testui",
"testuidev": "npx nightwatch --env=dev", "testuidev": "npx nightwatch --env=dev",
"lint": "npx grunt lint", "lint": "npx grunt lint",
"postinstall": "npx grunt exec:fixCryptoApiImports && npx grunt exec:fixSnackbarMarkup && npx grunt exec:fixJimpModule", "lint:grammar": "cspell ./src",
"postinstall": "npx grunt exec:fixCryptoApiImports && npx grunt exec:fixSnackbarMarkup",
"newop": "node --experimental-modules --experimental-json-modules src/core/config/scripts/newOperation.mjs", "newop": "node --experimental-modules --experimental-json-modules src/core/config/scripts/newOperation.mjs",
"minor": "node --experimental-modules --experimental-json-modules src/core/config/scripts/newMinorVersion.mjs", "minor": "node --experimental-modules --experimental-json-modules src/core/config/scripts/newMinorVersion.mjs && npm version minor --git-tag-version=false && echo \"Updated to version v$(npm pkg get version | xargs), please create a pull request and once merged use 'npm run tag'\"",
"tag": "git tag -s \"v$(npm pkg get version | xargs)\" -m \"$(npm pkg get version | xargs)\" && echo \"Created v$(npm pkg get version | xargs), now check and push the tag\"",
"getheapsize": "node -e 'console.log(`node heap limit = ${require(\"v8\").getHeapStatistics().heap_size_limit / (1024 * 1024)} Mb`)'", "getheapsize": "node -e 'console.log(`node heap limit = ${require(\"v8\").getHeapStatistics().heap_size_limit / (1024 * 1024)} Mb`)'",
"setheapsize": "export NODE_OPTIONS=--max_old_space_size=2048" "setheapsize": "export NODE_OPTIONS=--max_old_space_size=2048"
} }

1
src/core/Recipe.mjs
View File

@ -229,6 +229,7 @@ class Recipe {
} }
this.lastRunOp = op; this.lastRunOp = op;
} catch (err) { } catch (err) {
log.error(err);
// Return expected errors as output // Return expected errors as output
if (err instanceof OperationError || err?.type === "OperationError") { if (err instanceof OperationError || err?.type === "OperationError") {
// Cannot rely on `err instanceof OperationError` here as extending // Cannot rely on `err instanceof OperationError` here as extending

2
src/core/Utils.mjs
View File

@ -177,7 +177,7 @@ class Utils {
*/ */
static printable(str, preserveWs=false, onlyAscii=false) { static printable(str, preserveWs=false, onlyAscii=false) {
if (onlyAscii) { if (onlyAscii) {
return str.replace(/[^\x20-\x7f]/g, "."); return str.replace(/[^\x20-\x7e]/g, ".");
} }
// eslint-disable-next-line no-misleading-character-class // eslint-disable-next-line no-misleading-character-class

39
src/core/config/Categories.json
View File

@ -26,6 +26,8 @@
"From Base45", "From Base45",
"To Base58", "To Base58",
"From Base58", "From Base58",
"To Bech32",
"From Bech32",
"To Base62", "To Base62",
"From Base62", "From Base62",
"To Base64", "To Base64",
@ -72,9 +74,14 @@
"Avro to JSON", "Avro to JSON",
"CBOR Encode", "CBOR Encode",
"CBOR Decode", "CBOR Decode",
"YAML to JSON",
"JSON to YAML",
"Caret/M-decode", "Caret/M-decode",
"Rison Encode", "Rison Encode",
"Rison Decode" "Rison Decode",
"To Modhex",
"From Modhex",
"MIME Decoding"
] ]
}, },
{ {
@ -157,7 +164,10 @@
"Typex", "Typex",
"Lorenz", "Lorenz",
"Colossus", "Colossus",
"SIGABA" "SIGABA",
"Flask Session Decode",
"Flask Session Sign",
"Flask Session Verify"
] ]
}, },
{ {
@ -190,7 +200,9 @@
"Parse SSH Host Key", "Parse SSH Host Key",
"Parse CSR", "Parse CSR",
"Public Key from Certificate", "Public Key from Certificate",
"Public Key from Private Key" "Public Key from Private Key",
"SM2 Encrypt",
"SM2 Decrypt"
] ]
}, },
{ {
@ -213,6 +225,9 @@
"Subtract", "Subtract",
"Multiply", "Multiply",
"Divide", "Divide",
"Modular Exponentiation",
"Modular Inverse",
"Extended GCD",
"Mean", "Mean",
"Median", "Median",
"Standard Deviation", "Standard Deviation",
@ -287,6 +302,7 @@
"To Upper case", "To Upper case",
"To Lower case", "To Lower case",
"Swap case", "Swap case",
"Alternating Caps",
"To Case Insensitive Regex", "To Case Insensitive Regex",
"From Case Insensitive Regex", "From Case Insensitive Regex",
"Add line numbers", "Add line numbers",
@ -362,11 +378,13 @@
"Regular expression", "Regular expression",
"XPath expression", "XPath expression",
"JPath expression", "JPath expression",
"Jsonata Query",
"CSS selector", "CSS selector",
"Extract EXIF", "Extract EXIF",
"Extract ID3", "Extract ID3",
"Extract Files", "Extract Files",
"RAKE" "RAKE",
"Template"
] ]
}, },
{ {
@ -397,6 +415,7 @@
"name": "Hashing", "name": "Hashing",
"ops": [ "ops": [
"Analyse hash", "Analyse hash",
"Generate all checksums",
"Generate all hashes", "Generate all hashes",
"MD2", "MD2",
"MD4", "MD4",
@ -415,6 +434,7 @@
"Snefru", "Snefru",
"BLAKE2b", "BLAKE2b",
"BLAKE2s", "BLAKE2s",
"BLAKE3",
"GOST Hash", "GOST Hash",
"Streebog", "Streebog",
"SSDEEP", "SSDEEP",
@ -438,10 +458,9 @@
"Fletcher-64 Checksum", "Fletcher-64 Checksum",
"Adler-32 Checksum", "Adler-32 Checksum",
"Luhn Checksum", "Luhn Checksum",
"CRC-8 Checksum", "CRC Checksum",
"CRC-16 Checksum", "TCP/IP Checksum",
"CRC-32 Checksum", "XOR Checksum"
"TCP/IP Checksum"
] ]
}, },
{ {
@ -462,8 +481,10 @@
"CSS Minify", "CSS Minify",
"XPath expression", "XPath expression",
"JPath expression", "JPath expression",
"Jq",
"CSS selector", "CSS selector",
"PHP Deserialize", "PHP Deserialize",
"PHP Serialize",
"Microsoft Script Decoder", "Microsoft Script Decoder",
"Strip HTML tags", "Strip HTML tags",
"Diff", "Diff",
@ -536,8 +557,10 @@
"P-list Viewer", "P-list Viewer",
"Disassemble x86", "Disassemble x86",
"Pseudo-Random Number Generator", "Pseudo-Random Number Generator",
"Pseudo-Random Integer Generator",
"Generate De Bruijn Sequence", "Generate De Bruijn Sequence",
"Generate UUID", "Generate UUID",
"Analyse UUID",
"Generate TOTP", "Generate TOTP",
"Generate HOTP", "Generate HOTP",
"Generate QR Code", "Generate QR Code",

227
src/core/config/scripts/newMinorVersion.mjs
View File

@ -7,138 +7,197 @@
*/ */
/* eslint no-console: ["off"] */ /* eslint no-console: ["off"] */
/* eslint jsdoc/require-jsdoc: ["off"] */
import prompt from "prompt";
import colors from "colors";
import path from "path"; import path from "path";
import fs from "fs"; import fs from "fs";
import process from "process"; import process from "process";
import { execSync } from "child_process";
const ignoredAuthors = ["github-advanced-security[bot]", "dependabot[bot]"];
async function main() {
const dir = path.join(process.cwd() + "/src/core/config/"); const dir = path.join(process.cwd() + "/src/core/config/");
if (!fs.existsSync(dir)) { if (!fs.existsSync(dir)) {
console.log("\nCWD: " + process.cwd()); console.log("\nCWD: " + process.cwd());
console.log("Error: newMinorVersion.mjs should be run from the project root"); console.log(
console.log("Example> node --experimental-modules src/core/config/scripts/newMinorVersion.mjs"); "Error: newMinorVersion.mjs should be run from the project root",
);
console.log(
"Example> node --experimental-modules src/core/config/scripts/newMinorVersion.mjs",
);
process.exit(1); process.exit(1);
} }
let changelogData = fs.readFileSync(path.join(process.cwd(), "CHANGELOG.md"), "utf8"); let changelogData = fs.readFileSync(
const lastVersion = changelogData.match(/## Details\s+### \[(\d+)\.(\d+)\.(\d+)\]/); path.join(process.cwd(), "CHANGELOG.md"),
"utf8",
);
const lastVersion = changelogData.match(
/## Details\s+### \[(\d+)\.(\d+)\.(\d+)\]/,
);
const newVersion = [ const newVersion = [
parseInt(lastVersion[1], 10), parseInt(lastVersion[1], 10),
parseInt(lastVersion[2], 10) + 1, parseInt(lastVersion[2], 10) + 1,
0 0,
]; ];
let knownContributors = changelogData.match(/^\[@([^\]]+)\]/gm); let knownContributors = changelogData.match(/^\[@([^\]]+)\]/gm);
knownContributors = knownContributors.map(c => c.slice(2, -1)); knownContributors = knownContributors.map((c) => c.slice(2, -1));
const date = (new Date()).toISOString().split("T")[0]; const date = new Date().toISOString().split("T")[0];
const schema = { const lastVersionSha = execSync(
properties: { `git rev-list -n 1 v${lastVersion[1]}.${lastVersion[2]}.${lastVersion[3]}`,
message: { {
description: "A short but descriptive summary of a feature in this version", encoding: "utf8",
example: "Added 'Op name' operation",
prompt: "Feature description",
type: "string",
required: true,
}, },
author: { ).trim();
description: "The author of the feature (only one supported, edit manually to add more)", if (lastVersionSha.length !== 40) {
example: "n1474335", throw new Error(
prompt: "Author", `Unexpected output from git rev-list: ${lastVersionSha}`,
type: "string", );
default: "n1474335"
},
id: {
description: "The PR number or full commit hash for this feature.",
example: "1200",
prompt: "Pull request or commit ID",
type: "string"
},
another: {
description: "y/n",
example: "y",
prompt: "Add another feature?",
type: "string",
pattern: /^[yn]$/,
} }
}
};
// Build schema
for (const prop in schema.properties) {
const p = schema.properties[prop];
p.description = "\n" + colors.white(p.description) + colors.cyan("\nExample: " + p.example) + "\n" + colors.green(p.prompt);
}
prompt.message = "";
prompt.delimiter = ":".green;
const features = []; const features = [];
const commits = await (
await fetch(`https://api.github.com/repos/gchq/cyberchef/commits`)
).json();
let foundLast = false;
for (const commit of commits) {
if (commit.sha === lastVersionSha) {
foundLast = true;
break;
} else {
const feature = {
message: "",
authors: [],
id: "",
};
const msgparts = commit.commit.message.split("\n\n");
feature.message = msgparts[0];
const prIdMatch = feature.message.match(/\(#(\d+)\)$/);
if (prIdMatch !== null) {
feature.message = feature.message
.replace(prIdMatch[0], "")
.trim();
feature.id = prIdMatch[1];
}
if (!ignoredAuthors.includes(commit.author.login)) {
feature.authors.push(commit.author.login);
}
if (msgparts.length > 1) {
msgparts[1]
.split("\n")
.filter((line) => line.startsWith("Co-authored-by: "))
.forEach((line) => {
let coAuthor = line.slice("Co-authored-by: ".length);
if (coAuthor.indexOf(">") !== -1) {
const email = coAuthor.slice(
coAuthor.indexOf("<") + 1,
coAuthor.indexOf(">"),
);
if (email.endsWith("@users.noreply.github.com")) {
coAuthor = email.slice(
email.indexOf("+") + 1,
-"@users.noreply.github.com".length,
);
} else {
throw new Error(
"Could not get ID of co-author: " +
coAuthor,
);
}
} else {
throw new Error(
"Could not get email of co-author: " + coAuthor,
);
}
if (!ignoredAuthors.includes(coAuthor)) {
feature.authors.push(coAuthor);
}
});
}
features.push(feature);
}
}
if (!foundLast) {
throw new Error(
`Could not find last version commit: ${lastVersionSha} - need to add paging functionality`,
);
}
let message = `### [${newVersion[0]}.${newVersion[1]}.${newVersion[2]}] - ${date}\n`;
const authors = []; const authors = [];
const prIDs = []; const prIDs = [];
const commitIDs = []; const commitIDs = [];
prompt.start(); features.forEach((feature) => {
const id =
feature.id.length > 10 ? feature.id.slice(0, 7) : "#" + feature.id;
message += `- ${feature.message} ${feature.authors.map((a) => `[@${a}]`).join(" ")} | [${id}]\n`;
const getFeature = function() { feature.authors.forEach((author) => {
prompt.get(schema, (err, result) => { if (!knownContributors.includes(author)) {
if (err) { knownContributors.push(author);
console.log("\nExiting script."); authors.push(`[@${author}]: https://github.com/${author}`);
process.exit(0);
}
features.push(result);
if (result.another === "y") {
getFeature();
} else {
let message = `### [${newVersion[0]}.${newVersion[1]}.${newVersion[2]}] - ${date}\n`;
features.forEach(feature => {
const id = feature.id.length > 10 ? feature.id.slice(0, 7) : "#" + feature.id;
message += `- ${feature.message} [@${feature.author}] | [${id}]\n`;
if (!knownContributors.includes(feature.author)) {
authors.push(`[@${feature.author}]: https://github.com/${feature.author}`);
} }
});
if (feature.id.length > 10) { if (feature.id.length > 10) {
commitIDs.push(`[${id}]: https://github.com/gchq/CyberChef/commit/${feature.id}`); commitIDs.push(
`[${id}]: https://github.com/gchq/CyberChef/commit/${feature.id}`,
);
} else { } else {
prIDs.push(`[#${feature.id}]: https://github.com/gchq/CyberChef/pull/${feature.id}`); prIDs.push(
`[#${feature.id}]: https://github.com/gchq/CyberChef/pull/${feature.id}`,
);
} }
}); });
// Message // Message
changelogData = changelogData.replace(/## Details\n\n/, "## Details\n\n" + message + "\n"); changelogData = changelogData.replace(
/## Details\n\n/,
"## Details\n\n" + message + "\n",
);
// Tag // Tag
const newTag = `[${newVersion[0]}.${newVersion[1]}.${newVersion[2]}]: https://github.com/gchq/CyberChef/releases/tag/v${newVersion[0]}.${newVersion[1]}.${newVersion[2]}\n`; const newTag = `[${newVersion[0]}.${newVersion[1]}.${newVersion[2]}]: https://github.com/gchq/CyberChef/releases/tag/v${newVersion[0]}.${newVersion[1]}.${newVersion[2]}\n`;
changelogData = changelogData.replace(/\n\n(\[\d+\.\d+\.\d+\]: https)/, "\n\n" + newTag + "$1"); changelogData = changelogData.replace(
/\n\n(\[\d+\.\d+\.\d+\]: https)/,
"\n\n" + newTag + "$1",
);
// Author // Author
authors.forEach(author => { authors.forEach((author) => {
changelogData = changelogData.replace(/(\n\[@[^\]]+\]: https:\/\/github\.com\/[^\n]+\n)\n/, "$1" + author + "\n\n"); changelogData = changelogData.replace(
/(\n\[@[^\]]+\]: https:\/\/github\.com\/[^\n]+\n)\n/,
"$1" + author + "\n\n",
);
}); });
// Commit IDs // Commit IDs
commitIDs.forEach(commitID => { commitIDs.forEach((commitID) => {
changelogData = changelogData.replace(/(\n\[[^\].]+\]: https:\/\/github.com\/gchq\/CyberChef\/commit\/[^\n]+\n)\n/, "$1" + commitID + "\n\n"); changelogData = changelogData.replace(
/(\n\[[^\].]+\]: https:\/\/github.com\/gchq\/CyberChef\/commit\/[^\n]+\n)\n/,
"$1" + commitID + "\n\n",
);
}); });
// PR IDs // PR IDs
prIDs.forEach(prID => { prIDs.forEach((prID) => {
changelogData = changelogData.replace(/(\n\[#[^\]]+\]: https:\/\/github.com\/gchq\/CyberChef\/pull\/[^\n]+\n)\n*$/, "$1" + prID + "\n\n"); changelogData = changelogData.replace(
/(\n\[#[^\]]+\]: https:\/\/github.com\/gchq\/CyberChef\/(?:pull|issues)\/[^\n]+\n)\n*$/,
"$1" + prID + "\n\n",
);
}); });
fs.writeFileSync(path.join(process.cwd(), "CHANGELOG.md"), changelogData); fs.writeFileSync(path.join(process.cwd(), "CHANGELOG.md"), changelogData);
console.log("Written CHANGELOG.md\nCommit changes and then run `npm version minor`.");
} }
}); main().catch(console.error);
};
getFeature();

23
src/core/lib/Base32.mjs Normal file
View File

@ -0,0 +1,23 @@
// import Utils from "../Utils.mjs";
/**
* Base32 resources.
*
* @author Peter C-S [petercs@purelymail.com]
* @license Apache-2.0
*/
/**
* Base32 alphabets.
*/
export const ALPHABET_OPTIONS = [
{
name: "Standard", // https://www.rfc-editor.org/rfc/rfc4648#section-6
value: "A-Z2-7=",
},
{
name: "Hex Extended", // https://www.rfc-editor.org/rfc/rfc4648#section-7
value: "0-9A-V=",
},
];

371
src/core/lib/Bech32.mjs Normal file
View File

@ -0,0 +1,371 @@
/**
* Pure JavaScript implementation of Bech32 and Bech32m encoding.
*
* Bech32 is defined in BIP-0173: https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki
* Bech32m is defined in BIP-0350: https://github.com/bitcoin/bips/blob/master/bip-0350.mediawiki
*
* @author Medjedtxm
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import OperationError from "../errors/OperationError.mjs";
/** Bech32 character set (32 characters, excludes 1, b, i, o) */
const CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
/** Reverse lookup table for decoding */
const CHARSET_REV = {};
for (let i = 0; i < CHARSET.length; i++) {
CHARSET_REV[CHARSET[i]] = i;
}
/** Checksum constant for Bech32 (BIP-0173) */
const BECH32_CONST = 1;
/** Checksum constant for Bech32m (BIP-0350) */
const BECH32M_CONST = 0x2bc830a3;
/** Generator polynomial coefficients for checksum */
const GENERATOR = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3];
/**
* Compute the polymod checksum
* @param {number[]} values - Array of 5-bit values
* @returns {number} - Checksum value
*/
function polymod(values) {
let chk = 1;
for (const v of values) {
const top = chk >> 25;
chk = ((chk & 0x1ffffff) << 5) ^ v;
for (let i = 0; i < 5; i++) {
if ((top >> i) & 1) {
chk ^= GENERATOR[i];
}
}
}
return chk;
}
/**
* Expand HRP for checksum computation
* @param {string} hrp - Human-readable part (lowercase)
* @returns {number[]} - Expanded values
*/
function hrpExpand(hrp) {
const result = [];
for (let i = 0; i < hrp.length; i++) {
result.push(hrp.charCodeAt(i) >> 5);
}
result.push(0);
for (let i = 0; i < hrp.length; i++) {
result.push(hrp.charCodeAt(i) & 31);
}
return result;
}
/**
* Verify checksum of a Bech32/Bech32m string
* @param {string} hrp - Human-readable part (lowercase)
* @param {number[]} data - Data including checksum (5-bit values)
* @param {string} encoding - "Bech32" or "Bech32m"
* @returns {boolean} - True if checksum is valid
*/
function verifyChecksum(hrp, data, encoding) {
const constant = encoding === "Bech32m" ? BECH32M_CONST : BECH32_CONST;
return polymod(hrpExpand(hrp).concat(data)) === constant;
}
/**
* Create checksum for Bech32/Bech32m encoding
* @param {string} hrp - Human-readable part (lowercase)
* @param {number[]} data - Data values (5-bit)
* @param {string} encoding - "Bech32" or "Bech32m"
* @returns {number[]} - 6 checksum values
*/
function createChecksum(hrp, data, encoding) {
const constant = encoding === "Bech32m" ? BECH32M_CONST : BECH32_CONST;
const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
const mod = polymod(values) ^ constant;
const result = [];
for (let i = 0; i < 6; i++) {
result.push((mod >> (5 * (5 - i))) & 31);
}
return result;
}
/**
* Convert 8-bit bytes to 5-bit words
* @param {number[]|Uint8Array} data - Input bytes
* @returns {number[]} - 5-bit words
*/
export function toWords(data) {
let value = 0;
let bits = 0;
const result = [];
for (let i = 0; i < data.length; i++) {
value = (value << 8) | data[i];
bits += 8;
while (bits >= 5) {
bits -= 5;
result.push((value >> bits) & 31);
}
}
// Pad remaining bits
if (bits > 0) {
result.push((value << (5 - bits)) & 31);
}
return result;
}
/**
* Convert 5-bit words to 8-bit bytes
* @param {number[]} words - 5-bit words
* @returns {number[]} - Output bytes
*/
export function fromWords(words) {
let value = 0;
let bits = 0;
const result = [];
for (let i = 0; i < words.length; i++) {
value = (value << 5) | words[i];
bits += 5;
while (bits >= 8) {
bits -= 8;
result.push((value >> bits) & 255);
}
}
// Check for invalid padding per BIP-0173
// Condition 1: Cannot have 5+ bits remaining (would indicate incomplete byte)
if (bits >= 5) {
throw new OperationError("Invalid padding: too many bits remaining");
}
// Condition 2: Remaining padding bits must all be zero
if (bits > 0) {
const paddingValue = (value << (8 - bits)) & 255;
if (paddingValue !== 0) {
throw new OperationError("Invalid padding: non-zero bits in padding");
}
}
return result;
}
/**
* Encode data to Bech32/Bech32m string
*
* @param {string} hrp - Human-readable part
* @param {number[]|Uint8Array} data - Data bytes to encode
* @param {string} encoding - "Bech32" or "Bech32m"
* @param {boolean} segwit - If true, treat first byte as witness version (for Bitcoin SegWit)
* @returns {string} - Encoded Bech32/Bech32m string
*/
export function encode(hrp, data, encoding = "Bech32", segwit = false) {
// Validate HRP
if (!hrp || hrp.length === 0) {
throw new OperationError("Human-Readable Part (HRP) cannot be empty.");
}
// Check HRP characters (ASCII 33-126)
for (let i = 0; i < hrp.length; i++) {
const c = hrp.charCodeAt(i);
if (c < 33 || c > 126) {
throw new OperationError(`HRP contains invalid character at position ${i}. Only printable ASCII characters (33-126) are allowed.`);
}
}
// Convert HRP to lowercase
const hrpLower = hrp.toLowerCase();
let words;
if (segwit && data.length >= 2) {
// SegWit encoding: first byte is witness version (0-16), rest is witness program
const witnessVersion = data[0];
if (witnessVersion > 16) {
throw new OperationError(`Invalid witness version: ${witnessVersion}. Must be 0-16.`);
}
const witnessProgram = Array.prototype.slice.call(data, 1);
// Validate witness program length per BIP-0141
if (witnessProgram.length < 2 || witnessProgram.length > 40) {
throw new OperationError(`Invalid witness program length: ${witnessProgram.length}. Must be 2-40 bytes.`);
}
if (witnessVersion === 0 && witnessProgram.length !== 20 && witnessProgram.length !== 32) {
throw new OperationError(`Invalid witness program length for v0: ${witnessProgram.length}. Must be 20 or 32 bytes.`);
}
// Witness version is kept as single 5-bit value, program is converted
words = [witnessVersion].concat(toWords(witnessProgram));
} else {
// Generic encoding: convert all bytes to 5-bit words
words = toWords(data);
}
// Create checksum
const checksum = createChecksum(hrpLower, words, encoding);
// Build result string
let result = hrpLower + "1";
for (const w of words.concat(checksum)) {
result += CHARSET[w];
}
// Check maximum length (90 characters)
if (result.length > 90) {
throw new OperationError(`Encoded string exceeds maximum length of 90 characters (got ${result.length}). Consider using smaller input data.`);
}
return result;
}
/**
* Decode a Bech32/Bech32m string
*
* @param {string} str - Bech32/Bech32m encoded string
* @param {string} encoding - "Bech32", "Bech32m", or "Auto-detect"
* @returns {{hrp: string, data: number[]}} - Decoded HRP and data bytes
*/
export function decode(str, encoding = "Auto-detect") {
// Check for empty input
if (!str || str.length === 0) {
throw new OperationError("Input cannot be empty.");
}
// Check maximum length
if (str.length > 90) {
throw new OperationError(`Invalid Bech32 string: exceeds maximum length of 90 characters (got ${str.length}).`);
}
// Check for mixed case
const hasUpper = /[A-Z]/.test(str);
const hasLower = /[a-z]/.test(str);
if (hasUpper && hasLower) {
throw new OperationError("Invalid Bech32 string: mixed case is not allowed. Use all uppercase or all lowercase.");
}
// Convert to lowercase for processing
str = str.toLowerCase();
// Find separator (last occurrence of '1')
const sepIndex = str.lastIndexOf("1");
if (sepIndex === -1) {
throw new OperationError("Invalid Bech32 string: no separator '1' found.");
}
if (sepIndex === 0) {
throw new OperationError("Invalid Bech32 string: Human-Readable Part (HRP) cannot be empty.");
}
if (sepIndex + 7 > str.length) {
throw new OperationError("Invalid Bech32 string: data part is too short (minimum 6 characters for checksum).");
}
// Extract HRP and data part
const hrp = str.substring(0, sepIndex);
const dataPart = str.substring(sepIndex + 1);
// Validate HRP characters
for (let i = 0; i < hrp.length; i++) {
const c = hrp.charCodeAt(i);
if (c < 33 || c > 126) {
throw new OperationError(`HRP contains invalid character at position ${i}.`);
}
}
// Decode data characters to 5-bit values
const data = [];
for (let i = 0; i < dataPart.length; i++) {
const c = dataPart[i];
if (CHARSET_REV[c] === undefined) {
throw new OperationError(`Invalid character '${c}' at position ${sepIndex + 1 + i}.`);
}
data.push(CHARSET_REV[c]);
}
// Verify checksum
let usedEncoding;
if (encoding === "Bech32") {
if (!verifyChecksum(hrp, data, "Bech32")) {
throw new OperationError("Invalid Bech32 checksum.");
}
usedEncoding = "Bech32";
} else if (encoding === "Bech32m") {
if (!verifyChecksum(hrp, data, "Bech32m")) {
throw new OperationError("Invalid Bech32m checksum.");
}
usedEncoding = "Bech32m";
} else {
// Auto-detect: try Bech32 first, then Bech32m
if (verifyChecksum(hrp, data, "Bech32")) {
usedEncoding = "Bech32";
} else if (verifyChecksum(hrp, data, "Bech32m")) {
usedEncoding = "Bech32m";
} else {
throw new OperationError("Invalid Bech32/Bech32m string: checksum verification failed.");
}
}
// Remove checksum (last 6 values)
const words = data.slice(0, data.length - 6);
// Check if this is likely a SegWit address (Bitcoin, Litecoin, etc.)
// For SegWit, the first 5-bit word is the witness version (0-16)
// and should be extracted separately, not bit-converted with the rest
const segwitHrps = ["bc", "tb", "ltc", "tltc", "bcrt"];
const couldBeSegWit = segwitHrps.includes(hrp) && words.length > 0 && words[0] <= 16;
let bytes;
let witnessVersion = null;
if (couldBeSegWit) {
// Try SegWit decode first
try {
witnessVersion = words[0];
const programWords = words.slice(1);
const programBytes = fromWords(programWords);
// Validate SegWit witness program length (20 or 32 bytes for v0, 2-40 for others)
const validV0 = witnessVersion === 0 && (programBytes.length === 20 || programBytes.length === 32);
const validOther = witnessVersion !== 0 && programBytes.length >= 2 && programBytes.length <= 40;
if (validV0 || validOther) {
// Valid SegWit address
bytes = [witnessVersion, ...programBytes];
} else {
// Not valid SegWit, fall back to generic decode
witnessVersion = null;
bytes = fromWords(words);
}
} catch (e) {
// SegWit decode failed, try generic decode
witnessVersion = null;
try {
bytes = fromWords(words);
} catch (e2) {
throw new OperationError(`Failed to decode data: ${e2.message}`);
}
}
} else {
// Generic Bech32: convert all words
try {
bytes = fromWords(words);
} catch (e) {
throw new OperationError(`Failed to decode data: ${e.message}`);
}
}
return {
hrp: hrp,
data: bytes,
encoding: usedEncoding,
witnessVersion: witnessVersion
};
}

73
src/core/lib/BigIntUtils.mjs Normal file
View File

@ -0,0 +1,73 @@
/**
* @author p-leriche [philip.leriche@cantab.net]
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import OperationError from "../errors/OperationError.mjs";
/**
* Number theory utilities used by cryptographic operations.
*
* Currently provides:
* - parseBigInt
* - Extended Euclidean Algorithm
* - Modular Exponentiation
*
* Additional algorithms may be added as required.
*/
/**
* parseBigInt helper operation
*/
export function parseBigInt(value, param) {
const v = (value ?? "").trim();
if (/^0x[0-9a-f]+$/i.test(v)) return BigInt(v);
if (/^[+-]?[0-9]+$/.test(v)) return BigInt(v);
throw new OperationError(param + " must be decimal or hex (0x...)");
}
/**
* Extended Euclidean Algorithm
*
* Returns [g, x, y] such that:
* a*x + b*y = g = gcd(a, b)
*
* (Uses an iterative algorithm to avoid possible stack overflow)
*/
export function egcd(a, b) {
let oldR = a, r = b;
let oldS = 1n, s = 0n;
let oldT = 0n, t = 1n;
while (r !== 0n) {
const quotient = oldR / r;
[oldR, r] = [r, oldR - quotient * r];
[oldS, s] = [s, oldS - quotient * s];
[oldT, t] = [t, oldT - quotient * t];
}
// oldR is the gcd
// oldS and oldT are the Bézout coefficients
return [oldR, oldS, oldT];
}
/**
* Modular exponentiation
*/
export function modPow(base, exponent, modulus) {
let result = 1n;
base %= modulus;
while (exponent > 0n) {
if (exponent & 1n) {
result = (result * base) % modulus;
}
base = (base * base) % modulus;
exponent >>= 1n;
}
return result;
}

6
src/core/lib/Extract.mjs
View File

@ -62,3 +62,9 @@ export const URL_REGEX = new RegExp(protocol + hostname + "(?:" + port + ")?(?:"
* Domain name regular expression * Domain name regular expression
*/ */
export const DOMAIN_REGEX = /\b((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}\b/ig; export const DOMAIN_REGEX = /\b((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}\b/ig;
/**
* DMARC Domain name regular expression
*/
export const DMARC_DOMAIN_REGEX = /\b((?=[a-z0-9_-]{1,63}\.)(xn--)?[a-z0-9_]+(-[a-z0-9_]+)*\.)+[a-z]{2,63}\b/ig;

2
src/core/lib/Hex.mjs
View File

@ -33,7 +33,7 @@ export function toHex(data, delim=" ", padding=2, extraDelim="", lineSize=0) {
if (data instanceof ArrayBuffer) data = new Uint8Array(data); if (data instanceof ArrayBuffer) data = new Uint8Array(data);
let output = ""; let output = "";
const prepend = (delim === "0x" || delim === "\\x"); const prepend = (delim === "0x" || delim === "\\x" || delim === "%");
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
const hex = data[i].toString(16).padStart(padding, "0"); const hex = data[i].toString(16).padStart(padding, "0");

251
src/core/lib/ImageManipulation.mjs
View File

@ -1,251 +0,0 @@
/**
* Image manipulation resources
*
* @author j433866 [j433866@gmail.com]
* @copyright Crown Copyright 2019
* @license Apache-2.0
*/
import OperationError from "../errors/OperationError.mjs";
/**
* Gaussian blurs an image.
*
* @param {jimp} input
* @param {number} radius
* @param {boolean} fast
* @returns {jimp}
*/
export function gaussianBlur (input, radius) {
try {
// From http://blog.ivank.net/fastest-gaussian-blur.html
const boxes = boxesForGauss(radius, 3);
for (let i = 0; i < 3; i++) {
input = boxBlur(input, (boxes[i] - 1) / 2);
}
} catch (err) {
throw new OperationError(`Error blurring image. (${err})`);
}
return input;
}
/**
*
* @param {number} radius
* @param {number} numBoxes
* @returns {Array}
*/
function boxesForGauss(radius, numBoxes) {
const idealWidth = Math.sqrt((12 * radius * radius / numBoxes) + 1);
let wl = Math.floor(idealWidth);
if (wl % 2 === 0) {
wl--;
}
const wu = wl + 2;
const mIdeal = (12 * radius * radius - numBoxes * wl * wl - 4 * numBoxes * wl - 3 * numBoxes) / (-4 * wl - 4);
const m = Math.round(mIdeal);
const sizes = [];
for (let i = 0; i < numBoxes; i++) {
sizes.push(i < m ? wl : wu);
}
return sizes;
}
/**
* Applies a box blur effect to the image
*
* @param {jimp} source
* @param {number} radius
* @returns {jimp}
*/
function boxBlur (source, radius) {
const width = source.bitmap.width;
const height = source.bitmap.height;
let output = source.clone();
output = boxBlurH(source, output, width, height, radius);
source = boxBlurV(output, source, width, height, radius);
return source;
}
/**
* Applies the horizontal blur
*
* @param {jimp} source
* @param {jimp} output
* @param {number} width
* @param {number} height
* @param {number} radius
* @returns {jimp}
*/
function boxBlurH (source, output, width, height, radius) {
const iarr = 1 / (radius + radius + 1);
for (let i = 0; i < height; i++) {
let ti = 0,
li = ti,
ri = ti + radius;
const idx = source.getPixelIndex(ti, i);
const firstValRed = source.bitmap.data[idx],
firstValGreen = source.bitmap.data[idx + 1],
firstValBlue = source.bitmap.data[idx + 2],
firstValAlpha = source.bitmap.data[idx + 3];
const lastIdx = source.getPixelIndex(width - 1, i),
lastValRed = source.bitmap.data[lastIdx],
lastValGreen = source.bitmap.data[lastIdx + 1],
lastValBlue = source.bitmap.data[lastIdx + 2],
lastValAlpha = source.bitmap.data[lastIdx + 3];
let red = (radius + 1) * firstValRed;
let green = (radius + 1) * firstValGreen;
let blue = (radius + 1) * firstValBlue;
let alpha = (radius + 1) * firstValAlpha;
for (let j = 0; j < radius; j++) {
const jIdx = source.getPixelIndex(ti + j, i);
red += source.bitmap.data[jIdx];
green += source.bitmap.data[jIdx + 1];
blue += source.bitmap.data[jIdx + 2];
alpha += source.bitmap.data[jIdx + 3];
}
for (let j = 0; j <= radius; j++) {
const jIdx = source.getPixelIndex(ri++, i);
red += source.bitmap.data[jIdx] - firstValRed;
green += source.bitmap.data[jIdx + 1] - firstValGreen;
blue += source.bitmap.data[jIdx + 2] - firstValBlue;
alpha += source.bitmap.data[jIdx + 3] - firstValAlpha;
const tiIdx = source.getPixelIndex(ti++, i);
output.bitmap.data[tiIdx] = Math.round(red * iarr);
output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
}
for (let j = radius + 1; j < width - radius; j++) {
const riIdx = source.getPixelIndex(ri++, i);
const liIdx = source.getPixelIndex(li++, i);
red += source.bitmap.data[riIdx] - source.bitmap.data[liIdx];
green += source.bitmap.data[riIdx + 1] - source.bitmap.data[liIdx + 1];
blue += source.bitmap.data[riIdx + 2] - source.bitmap.data[liIdx + 2];
alpha += source.bitmap.data[riIdx + 3] - source.bitmap.data[liIdx + 3];
const tiIdx = source.getPixelIndex(ti++, i);
output.bitmap.data[tiIdx] = Math.round(red * iarr);
output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
}
for (let j = width - radius; j < width; j++) {
const liIdx = source.getPixelIndex(li++, i);
red += lastValRed - source.bitmap.data[liIdx];
green += lastValGreen - source.bitmap.data[liIdx + 1];
blue += lastValBlue - source.bitmap.data[liIdx + 2];
alpha += lastValAlpha - source.bitmap.data[liIdx + 3];
const tiIdx = source.getPixelIndex(ti++, i);
output.bitmap.data[tiIdx] = Math.round(red * iarr);
output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
}
}
return output;
}
/**
* Applies the vertical blur
*
* @param {jimp} source
* @param {jimp} output
* @param {number} width
* @param {number} height
* @param {number} radius
* @returns {jimp}
*/
function boxBlurV (source, output, width, height, radius) {
const iarr = 1 / (radius + radius + 1);
for (let i = 0; i < width; i++) {
let ti = 0,
li = ti,
ri = ti + radius;
const idx = source.getPixelIndex(i, ti);
const firstValRed = source.bitmap.data[idx],
firstValGreen = source.bitmap.data[idx + 1],
firstValBlue = source.bitmap.data[idx + 2],
firstValAlpha = source.bitmap.data[idx + 3];
const lastIdx = source.getPixelIndex(i, height - 1),
lastValRed = source.bitmap.data[lastIdx],
lastValGreen = source.bitmap.data[lastIdx + 1],
lastValBlue = source.bitmap.data[lastIdx + 2],
lastValAlpha = source.bitmap.data[lastIdx + 3];
let red = (radius + 1) * firstValRed;
let green = (radius + 1) * firstValGreen;
let blue = (radius + 1) * firstValBlue;
let alpha = (radius + 1) * firstValAlpha;
for (let j = 0; j < radius; j++) {
const jIdx = source.getPixelIndex(i, ti + j);
red += source.bitmap.data[jIdx];
green += source.bitmap.data[jIdx + 1];
blue += source.bitmap.data[jIdx + 2];
alpha += source.bitmap.data[jIdx + 3];
}
for (let j = 0; j <= radius; j++) {
const riIdx = source.getPixelIndex(i, ri++);
red += source.bitmap.data[riIdx] - firstValRed;
green += source.bitmap.data[riIdx + 1] - firstValGreen;
blue += source.bitmap.data[riIdx + 2] - firstValBlue;
alpha += source.bitmap.data[riIdx + 3] - firstValAlpha;
const tiIdx = source.getPixelIndex(i, ti++);
output.bitmap.data[tiIdx] = Math.round(red * iarr);
output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
}
for (let j = radius + 1; j < height - radius; j++) {
const riIdx = source.getPixelIndex(i, ri++);
const liIdx = source.getPixelIndex(i, li++);
red += source.bitmap.data[riIdx] - source.bitmap.data[liIdx];
green += source.bitmap.data[riIdx + 1] - source.bitmap.data[liIdx + 1];
blue += source.bitmap.data[riIdx + 2] - source.bitmap.data[liIdx + 2];
alpha += source.bitmap.data[riIdx + 3] - source.bitmap.data[liIdx + 3];
const tiIdx = source.getPixelIndex(i, ti++);
output.bitmap.data[tiIdx] = Math.round(red * iarr);
output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
}
for (let j = height - radius; j < height; j++) {
const liIdx = source.getPixelIndex(i, li++);
red += lastValRed - source.bitmap.data[liIdx];
green += lastValGreen - source.bitmap.data[liIdx + 1];
blue += lastValBlue - source.bitmap.data[liIdx + 2];
alpha += lastValAlpha - source.bitmap.data[liIdx + 3];
const tiIdx = source.getPixelIndex(i, ti++);
output.bitmap.data[tiIdx] = Math.round(red * iarr);
output.bitmap.data[tiIdx + 1] = Math.round(green * iarr);
output.bitmap.data[tiIdx + 2] = Math.round(blue * iarr);
output.bitmap.data[tiIdx + 3] = Math.round(alpha * iarr);
}
}
return output;
}

38
src/core/lib/JA4.mjs
View File

@ -91,9 +91,7 @@ export function toJA4(bytes) {
let alpn = "00"; let alpn = "00";
for (const ext of tlsr.handshake.value.extensions.value) { for (const ext of tlsr.handshake.value.extensions.value) {
if (ext.type.value === "application_layer_protocol_negotiation") { if (ext.type.value === "application_layer_protocol_negotiation") {
alpn = parseFirstALPNValue(ext.value.data); alpn = alpnFingerprint(parseFirstALPNValue(ext.value.data));
alpn = alpn.charAt(0) + alpn.charAt(alpn.length - 1);
if (alpn.charCodeAt(0) > 127) alpn = "99";
break; break;
} }
} }
@ -212,9 +210,7 @@ export function toJA4S(bytes) {
let alpn = "00"; let alpn = "00";
for (const ext of tlsr.handshake.value.extensions.value) { for (const ext of tlsr.handshake.value.extensions.value) {
if (ext.type.value === "application_layer_protocol_negotiation") { if (ext.type.value === "application_layer_protocol_negotiation") {
alpn = parseFirstALPNValue(ext.value.data); alpn = alpnFingerprint(parseFirstALPNValue(ext.value.data));
alpn = alpn.charAt(0) + alpn.charAt(alpn.length - 1);
if (alpn.charCodeAt(0) > 127) alpn = "99";
break; break;
} }
} }
@ -262,3 +258,33 @@ function tlsVersionMapper(version) {
default: return "00"; // Unknown default: return "00"; // Unknown
} }
} }
/**
* Checks if a byte is ASCII alphanumeric (0-9, A-Z, a-z).
* @param {number} byte
* @returns {boolean}
*/
function isAlphanumeric(byte) {
return (byte >= 0x30 && byte <= 0x39) ||
(byte >= 0x41 && byte <= 0x5A) ||
(byte >= 0x61 && byte <= 0x7A);
}
/**
* Computes the 2-character ALPN fingerprint from raw ALPN bytes.
* If both first and last bytes are ASCII alphanumeric, returns their characters.
* Otherwise, returns first hex digit of first byte + last hex digit of last byte.
* @param {Uint8Array|null} rawBytes
* @returns {string}
*/
function alpnFingerprint(rawBytes) {
if (!rawBytes || rawBytes.length === 0) return "00";
const firstByte = rawBytes[0];
const lastByte = rawBytes[rawBytes.length - 1];
if (isAlphanumeric(firstByte) && isAlphanumeric(lastByte)) {
return String.fromCharCode(firstByte) + String.fromCharCode(lastByte);
}
const firstHex = firstByte.toString(16).padStart(2, "0");
const lastHex = lastByte.toString(16).padStart(2, "0");
return firstHex[0] + lastHex[1];
}

165
src/core/lib/Modhex.mjs Normal file
View File

@ -0,0 +1,165 @@
/**
* @author linuxgemini [ilteris@asenkron.com.tr]
* @copyright Crown Copyright 2024
* @license Apache-2.0
*/
import Utils from "../Utils.mjs";
import OperationError from "../errors/OperationError.mjs";
import { fromHex, toHex } from "./Hex.mjs";
/**
* Modhex alphabet.
*/
const MODHEX_ALPHABET = "cbdefghijklnrtuv";
/**
* Modhex alphabet map.
*/
const MODHEX_ALPHABET_MAP = MODHEX_ALPHABET.split("");
/**
* Hex alphabet to substitute Modhex.
*/
const HEX_ALPHABET = "0123456789abcdef";
/**
* Hex alphabet map to substitute Modhex.
*/
const HEX_ALPHABET_MAP = HEX_ALPHABET.split("");
/**
* Convert a byte array into a modhex string.
*
* @param {byteArray|Uint8Array|ArrayBuffer} data
* @param {string} [delim=" "]
* @param {number} [padding=2]
* @returns {string}
*
* @example
* // returns "cl bf bu"
* toModhex([10,20,30]);
*
* // returns "cl:bf:bu"
* toModhex([10,20,30], ":");
*/
export function toModhex(data, delim=" ", padding=2, extraDelim="", lineSize=0) {
if (!data) return "";
if (data instanceof ArrayBuffer) data = new Uint8Array(data);
const regularHexString = toHex(data, "", padding, "", 0);
let modhexString = "";
for (const letter of regularHexString.split("")) {
modhexString += MODHEX_ALPHABET_MAP[HEX_ALPHABET_MAP.indexOf(letter)];
}
let output = "";
const groupingRegexp = new RegExp(`.{1,${padding}}`, "g");
const groupedModhex = modhexString.match(groupingRegexp);
for (let i = 0; i < groupedModhex.length; i++) {
const group = groupedModhex[i];
output += group + delim;
if (extraDelim) {
output += extraDelim;
}
// Add LF after each lineSize amount of bytes but not at the end
if ((i !== groupedModhex.length - 1) && ((i + 1) % lineSize === 0)) {
output += "\n";
}
}
// Remove the extraDelim at the end (if there is one)
// and remove the delim at the end, but if it's prepended there's nothing to remove
const rTruncLen = extraDelim.length + delim.length;
if (rTruncLen) {
// If rTruncLen === 0 then output.slice(0,0) will be returned, which is nothing
return output.slice(0, -rTruncLen);
} else {
return output;
}
}
/**
* Convert a byte array into a modhex string as efficiently as possible with no options.
*
* @param {byteArray|Uint8Array|ArrayBuffer} data
* @returns {string}
*
* @example
* // returns "clbfbu"
* toModhexFast([10,20,30]);
*/
export function toModhexFast(data) {
if (!data) return "";
if (data instanceof ArrayBuffer) data = new Uint8Array(data);
const output = [];
for (let i = 0; i < data.length; i++) {
output.push(MODHEX_ALPHABET_MAP[(data[i] >> 4) & 0xf]);
output.push(MODHEX_ALPHABET_MAP[data[i] & 0xf]);
}
return output.join("");
}
/**
* Convert a modhex string into a byte array.
*
* @param {string} data
* @param {string} [delim]
* @param {number} [byteLen=2]
* @returns {byteArray}
*
* @example
* // returns [10,20,30]
* fromModhex("cl bf bu");
*
* // returns [10,20,30]
* fromModhex("cl:bf:bu", "Colon");
*/
export function fromModhex(data, delim="Auto", byteLen=2) {
if (byteLen < 1 || Math.round(byteLen) !== byteLen)
throw new OperationError("Byte length must be a positive integer");
// The `.replace(/\s/g, "")` an interesting workaround: Hex "multiline" tests aren't actually
// multiline. Tests for Modhex fixes that, thus exposing the issue.
data = data.toLowerCase().replace(/\s/g, "");
if (delim !== "None") {
const delimRegex = delim === "Auto" ? /[^cbdefghijklnrtuv]/gi : Utils.regexRep(delim);
data = data.split(delimRegex);
} else {
data = [data];
}
let regularHexString = "";
for (let i = 0; i < data.length; i++) {
for (const letter of data[i].split("")) {
regularHexString += HEX_ALPHABET_MAP[MODHEX_ALPHABET_MAP.indexOf(letter)];
}
}
const output = fromHex(regularHexString, "None", byteLen);
return output;
}
/**
* To Modhex delimiters.
*/
export const TO_MODHEX_DELIM_OPTIONS = ["Space", "Percent", "Comma", "Semi-colon", "Colon", "Line feed", "CRLF", "None"];
/**
* From Modhex delimiters.
*/
export const FROM_MODHEX_DELIM_OPTIONS = ["Auto"].concat(TO_MODHEX_DELIM_OPTIONS);

40
src/core/lib/QRCode.mjs
View File

@ -10,7 +10,7 @@ import OperationError from "../errors/OperationError.mjs";
import jsQR from "jsqr"; import jsQR from "jsqr";
import qr from "qr-image"; import qr from "qr-image";
import Utils from "../Utils.mjs"; import Utils from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Parses a QR code image from an image * Parses a QR code image from an image
@ -29,18 +29,31 @@ export async function parseQrCode(input, normalise) {
try { try {
if (normalise) { if (normalise) {
image.rgba(false);
image.background(0xFFFFFFFF);
image.normalize();
image.greyscale(); image.greyscale();
image = await image.getBufferAsync(Jimp.MIME_JPEG); image.normalize();
image = await Jimp.read(image);
} }
} catch (err) { } catch (err) {
throw new OperationError(`Error normalising image. (${err})`); throw new OperationError(`Error normalising image. (${err})`);
} }
const qrData = jsQR(image.bitmap.data, image.getWidth(), image.getHeight()); // Remove transparency which jsQR cannot handle
image.scan((x, y, idx) => {
// If pixel is fully transparent, make it opaque white
if (image.bitmap.data[idx + 3] === 0x00) {
image.bitmap.data[idx + 0] = 0xff;
image.bitmap.data[idx + 1] = 0xff;
image.bitmap.data[idx + 2] = 0xff;
}
// Otherwise, make it fully opaque at its existing colour
image.bitmap.data[idx + 3] = 0xff;
});
image = await Jimp.read(await image.getBuffer(JimpMime.jpeg));
const qrData = jsQR(
new Uint8ClampedArray(image.bitmap.data),
image.width,
image.height,
);
if (qrData) { if (qrData) {
return qrData.data; return qrData.data;
} else { } else {
@ -58,7 +71,13 @@ export async function parseQrCode(input, normalise) {
* @param {string} errorCorrection * @param {string} errorCorrection
* @returns {ArrayBuffer} * @returns {ArrayBuffer}
*/ */
export function generateQrCode(input, format, moduleSize, margin, errorCorrection) { export function generateQrCode(
input,
format,
moduleSize,
margin,
errorCorrection,
) {
const formats = ["SVG", "EPS", "PDF", "PNG"]; const formats = ["SVG", "EPS", "PDF", "PNG"];
if (!formats.includes(format.toUpperCase())) { if (!formats.includes(format.toUpperCase())) {
throw new OperationError("Unsupported QR code format."); throw new OperationError("Unsupported QR code format.");
@ -70,7 +89,8 @@ export function generateQrCode(input, format, moduleSize, margin, errorCorrectio
type: format, type: format,
size: moduleSize, size: moduleSize,
margin: margin, margin: margin,
"ec_level": errorCorrection.charAt(0).toUpperCase() // eslint-disable-next-line camelcase
ec_level: errorCorrection.charAt(0).toUpperCase(),
}); });
} catch (err) { } catch (err) {
throw new OperationError(`Error generating QR code. (${err})`); throw new OperationError(`Error generating QR code. (${err})`);
@ -86,7 +106,7 @@ export function generateQrCode(input, format, moduleSize, margin, errorCorrectio
case "PDF": case "PDF":
return Utils.strToArrayBuffer(qrImage); return Utils.strToArrayBuffer(qrImage);
case "PNG": case "PNG":
return qrImage.buffer; return qrImage.buffer.slice(qrImage.byteOffset, qrImage.byteLength + qrImage.byteOffset);
default: default:
throw new OperationError("Unsupported QR code format."); throw new OperationError("Unsupported QR code format.");
} }

258
src/core/lib/SM2.mjs Normal file
View File

@ -0,0 +1,258 @@
/**
* Utilities and operations utilized for SM2 encryption and decryption
* @author flakjacket95 [dflack95@gmail.com]
* @copyright Crown Copyright 2024
* @license Apache-2.0
*/
import OperationError from "../errors/OperationError.mjs";
import { fromHex } from "../lib/Hex.mjs";
import Utils from "../Utils.mjs";
import Sm3 from "crypto-api/src/hasher/sm3.mjs";
import {toHex} from "crypto-api/src/encoder/hex.mjs";
import r from "jsrsasign";
/**
* SM2 Class for encryption and decryption operations
*/
export class SM2 {
/**
* Constructor for SM2 class; sets up with the curve and the output format as specified in user args
*
* @param {*} curve
* @param {*} format
*/
constructor(curve, format) {
this.ecParams = null;
this.rng = new r.SecureRandom();
/*
For any additional curve definitions utilized by SM2, add another block like the below for that curve, then add the curve name to the Curve selection dropdown
*/
r.crypto.ECParameterDB.regist(
"sm2p256v1", // name / p = 2**256 - 2**224 - 2**96 + 2**64 - 1
256,
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", // p
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFC", // a
"28E9FA9E9D9F5E344D5A9E4BCF6509A7F39789F515AB8F92DDBCBD414D940E93", // b
"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFF7203DF6B21C6052B53BBF40939D54123", // n
"1", // h
"32C4AE2C1F1981195F9904466A39C9948FE30BBFF2660BE1715A4589334C74C7", // gx
"BC3736A2F4F6779C59BDCEE36B692153D0A9877CC62A474002DF32E52139F0A0", // gy
[]
); // alias
this.ecParams = r.crypto.ECParameterDB.getByName(curve);
this.format = format;
}
/**
* Set the public key coordinates for the SM2 class
*
* @param {string} publicKeyX
* @param {string} publicKeyY
*/
setPublicKey(publicKeyX, publicKeyY) {
/*
* TODO: This needs some additional length validation; and checking for errors in the decoding process
* TODO: Can probably support other public key encoding methods here as well in the future
*/
this.publicKey = this.ecParams.curve.decodePointHex("04" + publicKeyX + publicKeyY);
if (this.publicKey.isInfinity()) {
throw new OperationError("Invalid Public Key");
}
}
/**
* Set the private key value for the SM2 class
*
* @param {string} privateKey
*/
setPrivateKey(privateKeyHex) {
this.privateKey = new r.BigInteger(privateKeyHex, 16);
}
/**
* Main encryption function; takes user input, processes encryption and returns the result in hex (with the components arranged as configured by the user args)
*
* @param {*} input
* @returns {string}
*/
encrypt(input) {
const G = this.ecParams.G;
/*
* Compute a new, random public key along the same elliptic curve to form the starting point for our encryption process (record the resulting X and Y as hex to provide as part of the operation output)
* k: Randomly generated BigInteger
* c1: Result of dotting our curve generator point `G` with the value of `k`
*/
const k = this.generatePublicKey();
const c1 = G.multiply(k);
const [hexC1X, hexC1Y] = this.getPointAsHex(c1);
/*
* Compute p2 (secret) using the public key, and the chosen k value above
*/
const p2 = this.publicKey.multiply(k);
/*
* Compute the C3 SM3 hash before we transform the array
*/
const c3 = this.c3(p2, input);
/*
* Genreate a proper length encryption key, XOR iteratively, and convert newly encrypted data to hex
*/
const key = this.kdf(p2, input.byteLength);
for (let i = 0; i < input.byteLength; i++) {
input[i] ^= Utils.ord(key[i]);
}
const c2 = Buffer.from(input).toString("hex");
/*
* Check user input specs; order the output components as selected
*/
if (this.format === "C1C3C2") {
return hexC1X + hexC1Y + c3 + c2;
} else {
return hexC1X + hexC1Y + c2 + c3;
}
}
/**
* Function to decrypt an SM2 encrypted message
*
* @param {*} input
*/
decrypt(input) {
const c1X = input.slice(0, 64);
const c1Y = input.slice(64, 128);
let c3 = "";
let c2 = "";
if (this.format === "C1C3C2") {
c3 = input.slice(128, 192);
c2 = input.slice(192);
} else {
c2 = input.slice(128, -64);
c3 = input.slice(-64);
}
c2 = Uint8Array.from(fromHex(c2));
const c1 = this.ecParams.curve.decodePointHex("04" + c1X + c1Y);
/*
* Compute the p2 (secret) value by taking the C1 point provided in the encrypted package, and multiplying by the private k value
*/
const p2 = c1.multiply(this.privateKey);
/*
* Similar to encryption; compute sufficient length key material and XOR the input data to recover the original message
*/
const key = this.kdf(p2, c2.byteLength);
for (let i = 0; i < c2.byteLength; i++) {
c2[i] ^= Utils.ord(key[i]);
}
const check = this.c3(p2, c2);
if (check === c3) {
return c2.buffer;
} else {
throw new OperationError("Decryption Error -- Computed Hashes Do Not Match");
}
}
/**
* Generates a large random number
*
* @param {*} limit
* @returns
*/
getBigRandom(limit) {
return new r.BigInteger(limit.bitLength(), this.rng)
.mod(limit.subtract(r.BigInteger.ONE))
.add(r.BigInteger.ONE);
}
/**
* Helper function for generating a large random K number; utilized for generating our initial C1 point
* TODO: Do we need to do any sort of validation on the resulting k values?
*
* @returns {BigInteger}
*/
generatePublicKey() {
const n = this.ecParams.n;
const k = this.getBigRandom(n);
return k;
}
/**
* SM2 Key Derivation Function (KDF); Takes P2 point, and generates a key material stream large enough to encrypt all of the input data
*
* @param {*} p2
* @param {*} len
* @returns {string}
*/
kdf(p2, len) {
const [hX, hY] = this.getPointAsHex(p2);
const total = Math.ceil(len / 32) + 1;
let cnt = 1;
let keyMaterial = "";
while (cnt < total) {
const num = Utils.intToByteArray(cnt, 4, "big");
const overall = fromHex(hX).concat(fromHex(hY)).concat(num);
keyMaterial += this.sm3(overall);
cnt++;
}
return keyMaterial;
}
/**
* Calculates the C3 component of our final encrypted payload; which is the SM3 hash of the P2 point and the original, unencrypted input data
*
* @param {*} p2
* @param {*} input
* @returns {string}
*/
c3(p2, input) {
const [hX, hY] = this.getPointAsHex(p2);
const overall = fromHex(hX).concat(Array.from(input)).concat(fromHex(hY));
return toHex(this.sm3(overall));
}
/**
* SM3 setup helper function; takes input data as an array, processes the hash and returns the result
*
* @param {*} data
* @returns {string}
*/
sm3(data) {
const hashData = Utils.arrayBufferToStr(Uint8Array.from(data).buffer, false);
const hasher = new Sm3();
hasher.update(hashData);
return hasher.finalize();
}
/**
* Utility function, returns an elliptic curve points X and Y values as hex;
*
* @param {EcPointFp} point
* @returns {[]}
*/
getPointAsHex(point) {
const biX = point.getX().toBigInteger();
const biY = point.getY().toBigInteger();
const charlen = this.ecParams.keycharlen;
const hX = ("0000000000" + biX.toString(16)).slice(- charlen);
const hY = ("0000000000" + biY.toString(16)).slice(- charlen);
return [hX, hY];
}
}

10
src/core/lib/TLS.mjs
View File

@ -863,15 +863,15 @@ export function parseHighestSupportedVersion(bytes) {
} }
/** /**
* Parses the application_layer_protocol_negotiation extension and returns the first value. * Parses the application_layer_protocol_negotiation extension and returns the first value as raw bytes.
* @param {Uint8Array} bytes * @param {Uint8Array} bytes
* @returns {number} * @returns {Uint8Array|null}
*/ */
export function parseFirstALPNValue(bytes) { export function parseFirstALPNValue(bytes) {
const s = new Stream(bytes); const s = new Stream(bytes);
const alpnExtLen = s.readInt(2); const alpnExtLen = s.readInt(2);
if (alpnExtLen < 3) return "00"; if (alpnExtLen < 2) return null;
const strLen = s.readInt(1); const strLen = s.readInt(1);
if (strLen < 2) return "00"; if (strLen < 1) return null;
return s.readString(strLen); return s.getBytes(strLen);
} }

2
src/core/operations/AESDecrypt.mjs
View File

@ -112,7 +112,7 @@ class AESDecrypt extends Operation {
run(input, args) { run(input, args) {
const key = Utils.convertToByteString(args[0].string, args[0].option), const key = Utils.convertToByteString(args[0].string, args[0].option),
iv = Utils.convertToByteString(args[1].string, args[1].option), iv = Utils.convertToByteString(args[1].string, args[1].option),
mode = args[2].substring(0, 3), mode = args[2].split("/")[0],
noPadding = args[2].endsWith("NoPadding"), noPadding = args[2].endsWith("NoPadding"),
inputType = args[3], inputType = args[3],
outputType = args[4], outputType = args[4],

20
src/core/operations/AESEncrypt.mjs
View File

@ -66,6 +66,14 @@ class AESEncrypt extends Operation {
{ {
name: "ECB", name: "ECB",
off: [5] off: [5]
},
{
name: "CBC/NoPadding",
off: [5]
},
{
name: "ECB/NoPadding",
off: [5]
} }
] ]
}, },
@ -98,7 +106,8 @@ class AESEncrypt extends Operation {
run(input, args) { run(input, args) {
const key = Utils.convertToByteString(args[0].string, args[0].option), const key = Utils.convertToByteString(args[0].string, args[0].option),
iv = Utils.convertToByteString(args[1].string, args[1].option), iv = Utils.convertToByteString(args[1].string, args[1].option),
mode = args[2], mode = args[2].split("/")[0],
noPadding = args[2].endsWith("NoPadding"),
inputType = args[3], inputType = args[3],
outputType = args[4], outputType = args[4],
aad = Utils.convertToByteString(args[5].string, args[5].option); aad = Utils.convertToByteString(args[5].string, args[5].option);
@ -114,11 +123,20 @@ The following algorithms will be used based on the size of the key:
input = Utils.convertToByteString(input, inputType); input = Utils.convertToByteString(input, inputType);
// Handle NoPadding modes
if (noPadding && input.length % 16 !== 0) {
throw new OperationError("Input length must be a multiple of 16 bytes for NoPadding modes.");
}
const cipher = forge.cipher.createCipher("AES-" + mode, key); const cipher = forge.cipher.createCipher("AES-" + mode, key);
cipher.start({ cipher.start({
iv: iv, iv: iv,
additionalData: mode === "GCM" ? aad : undefined additionalData: mode === "GCM" ? aad : undefined
}); });
if (noPadding) {
cipher.mode.pad = function(output, options) {
return true;
};
}
cipher.update(forge.util.createBuffer(input)); cipher.update(forge.util.createBuffer(input));
cipher.finish(); cipher.finish();

162
src/core/operations/AddTextToImage.mjs
View File

@ -9,13 +9,19 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import {
Jimp,
JimpMime,
ResizeStrategy,
measureText,
measureTextHeight,
loadFont,
} from "jimp";
/** /**
* Add Text To Image operation * Add Text To Image operation
*/ */
class AddTextToImage extends Operation { class AddTextToImage extends Operation {
/** /**
* AddTextToImage constructor * AddTextToImage constructor
*/ */
@ -24,7 +30,8 @@ class AddTextToImage extends Operation {
this.name = "Add Text To Image"; this.name = "Add Text To Image";
this.module = "Image"; this.module = "Image";
this.description = "Adds text onto an image.<br><br>Text can be horizontally or vertically aligned, or the position can be manually specified.<br>Variants of the Roboto font face are available in any size or colour."; this.description =
"Adds text onto an image.<br><br>Text can be horizontally or vertically aligned, or the position can be manually specified.<br>Variants of the Roboto font face are available in any size or colour.";
this.infoURL = ""; this.infoURL = "";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -33,72 +40,67 @@ class AddTextToImage extends Operation {
{ {
name: "Text", name: "Text",
type: "string", type: "string",
value: "" value: "",
}, },
{ {
name: "Horizontal align", name: "Horizontal align",
type: "option", type: "option",
value: ["None", "Left", "Center", "Right"] value: ["None", "Left", "Center", "Right"],
}, },
{ {
name: "Vertical align", name: "Vertical align",
type: "option", type: "option",
value: ["None", "Top", "Middle", "Bottom"] value: ["None", "Top", "Middle", "Bottom"],
}, },
{ {
name: "X position", name: "X position",
type: "number", type: "number",
value: 0 value: 0,
}, },
{ {
name: "Y position", name: "Y position",
type: "number", type: "number",
value: 0 value: 0,
}, },
{ {
name: "Size", name: "Size",
type: "number", type: "number",
value: 32, value: 32,
min: 8 min: 8,
}, },
{ {
name: "Font face", name: "Font face",
type: "option", type: "option",
value: [ value: ["Roboto", "Roboto Black", "Roboto Mono", "Roboto Slab"],
"Roboto",
"Roboto Black",
"Roboto Mono",
"Roboto Slab"
]
}, },
{ {
name: "Red", name: "Red",
type: "number", type: "number",
value: 255, value: 255,
min: 0, min: 0,
max: 255 max: 255,
}, },
{ {
name: "Green", name: "Green",
type: "number", type: "number",
value: 255, value: 255,
min: 0, min: 0,
max: 255 max: 255,
}, },
{ {
name: "Blue", name: "Blue",
type: "number", type: "number",
value: 255, value: 255,
min: 0, min: 0,
max: 255 max: 255,
}, },
{ {
name: "Alpha", name: "Alpha",
type: "number", type: "number",
value: 255, value: 255,
min: 0, min: 0,
max: 255 max: 255,
} },
]; ];
} }
@ -131,39 +133,58 @@ class AddTextToImage extends Operation {
} catch (err) { } catch (err) {
throw new OperationError(`Error loading image. (${err})`); throw new OperationError(`Error loading image. (${err})`);
} }
try {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Adding text to image..."); self.sendStatusMessage("Adding text to image...");
const fontsMap = {}; const fontsMap = {};
try {
const fonts = [ const fonts = [
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt"), import(
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt"), /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.fnt"
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt"), ),
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt") import(
/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.fnt"
),
import(
/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.fnt"
),
import(
/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.fnt"
),
]; ];
await Promise.all(fonts) await Promise.all(fonts).then((fonts) => {
.then(fonts => {
fontsMap.Roboto = fonts[0]; fontsMap.Roboto = fonts[0];
fontsMap["Roboto Black"] = fonts[1]; fontsMap["Roboto Black"] = fonts[1];
fontsMap["Roboto Mono"] = fonts[2]; fontsMap["Roboto Mono"] = fonts[2];
fontsMap["Roboto Slab"] = fonts[3]; fontsMap["Roboto Slab"] = fonts[3];
}); });
// Make Webpack load the png font images // Make Webpack load the png font images
await Promise.all([ await Promise.all([
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png"), import(
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png"), /* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/Roboto72White.png"
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png"), ),
import(/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png") import(
/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoSlab72White.png"
),
import(
/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoMono72White.png"
),
import(
/* webpackMode: "eager" */ "../../web/static/fonts/bmfonts/RobotoBlack72White.png"
),
]); ]);
} catch (err) {
throw new OperationError(`Error preparing fonts. (${err})`);
}
let jimpFont;
try {
const font = fontsMap[fontFace]; const font = fontsMap[fontFace];
// LoadFont needs an absolute url, so append the font name to self.docURL // LoadFont needs an absolute url, so append the font name to self.docURL
const jimpFont = await Jimp.loadFont(self.docURL + "/" + font.default); jimpFont = await loadFont(self.docURL + "/" + font.default);
jimpFont.pages.forEach(function (page) { jimpFont.pages.forEach(function (page) {
if (page.bitmap) { if (page.bitmap) {
@ -175,32 +196,56 @@ class AddTextToImage extends Operation {
const idx = (iy * pageWidth + ix) << 2; const idx = (iy * pageWidth + ix) << 2;
const newRed = page.bitmap.data[idx] - (255 - red); const newRed = page.bitmap.data[idx] - (255 - red);
const newGreen = page.bitmap.data[idx + 1] - (255 - green); const newGreen =
const newBlue = page.bitmap.data[idx + 2] - (255 - blue); page.bitmap.data[idx + 1] - (255 - green);
const newAlpha = page.bitmap.data[idx + 3] - (255 - alpha); const newBlue =
page.bitmap.data[idx + 2] - (255 - blue);
const newAlpha =
page.bitmap.data[idx + 3] - (255 - alpha);
// Make sure the bitmap values don't go below 0 as that makes jimp very unhappy // Make sure the bitmap values don't go below 0 as that makes jimp very unhappy
page.bitmap.data[idx] = (newRed > 0) ? newRed : 0; page.bitmap.data[idx] = newRed > 0 ? newRed : 0;
page.bitmap.data[idx + 1] = (newGreen > 0) ? newGreen : 0; page.bitmap.data[idx + 1] =
page.bitmap.data[idx + 2] = (newBlue > 0) ? newBlue : 0; newGreen > 0 ? newGreen : 0;
page.bitmap.data[idx + 3] = (newAlpha > 0) ? newAlpha : 0; page.bitmap.data[idx + 2] =
newBlue > 0 ? newBlue : 0;
page.bitmap.data[idx + 3] =
newAlpha > 0 ? newAlpha : 0;
} }
} }
} }
}); });
} catch (err) {
throw new OperationError(`Error loading font. (${err})`);
}
try {
// Create a temporary image to hold the rendered text // Create a temporary image to hold the rendered text
const textImage = new Jimp(Jimp.measureText(jimpFont, text), Jimp.measureTextHeight(jimpFont, text)); const textImage = new Jimp({
textImage.print(jimpFont, 0, 0, text); width: measureText(jimpFont, text),
height: measureTextHeight(jimpFont, text),
});
textImage.print({
font: jimpFont,
x: 0,
y: 0,
text,
});
// Scale the rendered text image to the correct size // Scale the rendered text image to the correct size
const scaleFactor = size / 72; const scaleFactor = size / 72;
if (size !== 1) { if (size !== 1) {
// Use bicubic for decreasing size // Use bicubic for decreasing size
if (size > 1) { if (size > 1) {
textImage.scale(scaleFactor, Jimp.RESIZE_BICUBIC); textImage.scale({
f: scaleFactor,
mode: ResizeStrategy.BICUBIC,
});
} else { } else {
textImage.scale(scaleFactor, Jimp.RESIZE_BILINEAR); textImage.scale({
f: scaleFactor,
mode: ResizeStrategy.BILINEAR,
});
} }
} }
@ -210,10 +255,10 @@ class AddTextToImage extends Operation {
xPos = 0; xPos = 0;
break; break;
case "Center": case "Center":
xPos = (image.getWidth() / 2) - (textImage.getWidth() / 2); xPos = image.width / 2 - textImage.width / 2;
break; break;
case "Right": case "Right":
xPos = image.getWidth() - textImage.getWidth(); xPos = image.width - textImage.width;
break; break;
} }
@ -222,25 +267,33 @@ class AddTextToImage extends Operation {
yPos = 0; yPos = 0;
break; break;
case "Middle": case "Middle":
yPos = (image.getHeight() / 2) - (textImage.getHeight() / 2); yPos = image.height / 2 - textImage.height / 2;
break; break;
case "Bottom": case "Bottom":
yPos = image.getHeight() - textImage.getHeight(); yPos = image.height - textImage.height;
break; break;
} }
// Blit the rendered text image onto the original source image // Blit the rendered text image onto the original source image
image.blit(textImage, xPos, yPos); image.blit({
src: textImage,
x: xPos,
y: yPos,
});
} catch (err) {
throw new OperationError(`Error adding text to image. (${err})`);
}
try {
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error adding text to image. (${err})`); throw new OperationError(`Error exporting image. (${err})`);
} }
} }
@ -261,7 +314,6 @@ class AddTextToImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default AddTextToImage; export default AddTextToImage;

53
src/core/operations/AlternatingCaps.mjs Normal file
View File

@ -0,0 +1,53 @@
/**
* @author sw5678
* @copyright Crown Copyright 2023
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
/**
* Alternating caps operation
*/
class AlternatingCaps extends Operation {
/**
* AlternatingCaps constructor
*/
constructor() {
super();
this.name = "Alternating Caps";
this.module = "Default";
this.description = "Alternating caps, also known as studly caps, sticky caps, or spongecase is a form of text notation in which the capitalization of letters varies by some pattern, or arbitrarily. An example of this would be spelling 'alternative caps' as 'aLtErNaTiNg CaPs'.";
this.infoURL = "https://en.wikipedia.org/wiki/Alternating_caps";
this.inputType = "string";
this.outputType = "string";
this.args= [];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
let output = "";
let previousCaps = true;
for (let i = 0; i < input.length; i++) {
// Check if the element is a letter
if (!RegExp(/^\p{L}/, "u").test(input[i])) {
output += input[i];
} else if (previousCaps) {
output += input[i].toLowerCase();
previousCaps = false;
} else {
output += input[i].toUpperCase();
previousCaps = true;
}
}
return output;
}
}
export default AlternatingCaps;

48
src/core/operations/AnalyseUUID.mjs Normal file
View File

@ -0,0 +1,48 @@
/**
* @author n1474335 [n1474335@gmail.com]
* @copyright Crown Copyright 2023
* @license Apache-2.0
*/
import * as uuid from "uuid";
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
/**
* Analyse UUID operation
*/
class AnalyseUUID extends Operation {
/**
* AnalyseUUID constructor
*/
constructor() {
super();
this.name = "Analyse UUID";
this.module = "Crypto";
this.description = "Tries to determine information about a given UUID and suggests which version may have been used to generate it";
this.infoURL = "https://wikipedia.org/wiki/Universally_unique_identifier";
this.inputType = "string";
this.outputType = "string";
this.args = [];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
try {
const uuidVersion = uuid.version(input);
return "UUID version: " + uuidVersion;
} catch (error) {
throw new OperationError("Invalid UUID");
}
}
}
export default AnalyseUUID;

58
src/core/operations/BLAKE3.mjs Normal file
View File

@ -0,0 +1,58 @@
/**
* @author xumptex [xumptex@outlook.fr]
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import { blake3 } from "hash-wasm";
/**
* BLAKE3 operation
*/
class BLAKE3 extends Operation {
/**
* BLAKE3 constructor
*/
constructor() {
super();
this.name = "BLAKE3";
this.module = "Hashing";
this.description = "Hashes the input using BLAKE3 (UTF-8 encoded), with an optional key (also UTF-8), and outputs the result in hexadecimal format.";
this.infoURL = "https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE3";
this.inputType = "string";
this.outputType = "string";
this.args = [
{
"name": "Size (bytes)",
"type": "number"
}, {
"name": "Key",
"type": "string",
"value": ""
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const key = args[1];
const size = args[0];
// Check if the user want a key hash or not
if (key === "") {
return blake3(input, size*8);
} if (key.length !== 32) {
throw new OperationError("The key must be exactly 32 bytes long");
}
return blake3(input, size*8, key);
}
}
export default BLAKE3;

22
src/core/operations/BlurImage.mjs
View File

@ -9,14 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { gaussianBlur } from "../lib/ImageManipulation.mjs"; import { Jimp, JimpMime } from "jimp";
import Jimp from "jimp/es/index.js";
/** /**
* Blur Image operation * Blur Image operation
*/ */
class BlurImage extends Operation { class BlurImage extends Operation {
/** /**
* BlurImage constructor * BlurImage constructor
*/ */
@ -25,7 +23,8 @@ class BlurImage extends Operation {
this.name = "Blur Image"; this.name = "Blur Image";
this.module = "Image"; this.module = "Image";
this.description = "Applies a blur effect to the image.<br><br>Gaussian blur is much slower than fast blur, but produces better results."; this.description =
"Applies a blur effect to the image.<br><br>Gaussian blur is much slower than fast blur, but produces better results.";
this.infoURL = "https://wikipedia.org/wiki/Gaussian_blur"; this.infoURL = "https://wikipedia.org/wiki/Gaussian_blur";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -35,13 +34,13 @@ class BlurImage extends Operation {
name: "Amount", name: "Amount",
type: "number", type: "number",
value: 5, value: 5,
min: 1 min: 1,
}, },
{ {
name: "Type", name: "Type",
type: "option", type: "option",
value: ["Fast", "Gaussian"] value: ["Fast", "Gaussian"],
} },
]; ];
} }
@ -73,15 +72,15 @@ class BlurImage extends Operation {
case "Gaussian": case "Gaussian":
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Gaussian blurring image..."); self.sendStatusMessage("Gaussian blurring image...");
image = gaussianBlur(image, blurAmount); image.gaussian(blurAmount);
break; break;
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -106,7 +105,6 @@ class BlurImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default BlurImage; export default BlurImage;

41
src/core/operations/CRC16Checksum.mjs
View File

@ -1,41 +0,0 @@
/**
* @author n1474335 [n1474335@gmail.com]
* @copyright Crown Copyright 2016
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import JSCRC from "js-crc";
/**
* CRC-16 Checksum operation
*/
class CRC16Checksum extends Operation {
/**
* CRC16Checksum constructor
*/
constructor() {
super();
this.name = "CRC-16 Checksum";
this.module = "Crypto";
this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961.";
this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [];
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
return JSCRC.crc16(input);
}
}
export default CRC16Checksum;

41
src/core/operations/CRC32Checksum.mjs
View File

@ -1,41 +0,0 @@
/**
* @author n1474335 [n1474335@gmail.com]
* @copyright Crown Copyright 2016
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import JSCRC from "js-crc";
/**
* CRC-32 Checksum operation
*/
class CRC32Checksum extends Operation {
/**
* CRC32Checksum constructor
*/
constructor() {
super();
this.name = "CRC-32 Checksum";
this.module = "Crypto";
this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961; the 32-bit CRC function of Ethernet and many other standards is the work of several researchers and was published in 1975.";
this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [];
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
return JSCRC.crc32(input);
}
}
export default CRC32Checksum;

157
src/core/operations/CRC8Checksum.mjs
View File

@ -1,157 +0,0 @@
/**
* @author mshwed [m@ttshwed.com]
* @copyright Crown Copyright 2019
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import { toHexFast } from "../lib/Hex.mjs";
/**
* CRC-8 Checksum operation
*/
class CRC8Checksum extends Operation {
/**
* CRC8Checksum constructor
*/
constructor() {
super();
this.name = "CRC-8 Checksum";
this.module = "Crypto";
this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961.";
this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [
{
"name": "Algorithm",
"type": "option",
"value": [
"CRC-8",
"CRC-8/CDMA2000",
"CRC-8/DARC",
"CRC-8/DVB-S2",
"CRC-8/EBU",
"CRC-8/I-CODE",
"CRC-8/ITU",
"CRC-8/MAXIM",
"CRC-8/ROHC",
"CRC-8/WCDMA"
]
}
];
}
/**
* Generates the pre-computed lookup table for byte division
*
* @param polynomial
*/
calculateCRC8LookupTable(polynomial) {
const crc8Table = new Uint8Array(256);
let currentByte;
for (let i = 0; i < 256; i++) {
currentByte = i;
for (let bit = 0; bit < 8; bit++) {
if ((currentByte & 0x80) !== 0) {
currentByte <<= 1;
currentByte ^= polynomial;
} else {
currentByte <<= 1;
}
}
crc8Table[i] = currentByte;
}
return crc8Table;
}
/**
* Calculates the CRC-8 Checksum from an input
*
* @param {ArrayBuffer} input
* @param {number} polynomial
* @param {number} initializationValue
* @param {boolean} inputReflection
* @param {boolean} outputReflection
* @param {number} xorOut
*/
calculateCRC8(input, polynomial, initializationValue, inputReflection, outputReflection, xorOut) {
const crcSize = 8;
const crcTable = this.calculateCRC8LookupTable(polynomial);
let crc = initializationValue !== 0 ? initializationValue : 0;
let currentByte, position;
input = new Uint8Array(input);
for (const inputByte of input) {
currentByte = inputReflection ? this.reverseBits(inputByte, crcSize) : inputByte;
position = (currentByte ^ crc) & 255;
crc = crcTable[position];
}
crc = outputReflection ? this.reverseBits(crc, crcSize) : crc;
if (xorOut !== 0) crc = crc ^ xorOut;
return toHexFast(new Uint8Array([crc]));
}
/**
* Reverse the bits for a given input byte.
*
* @param {number} input
*/
reverseBits(input, hashSize) {
let reversedByte = 0;
for (let i = hashSize - 1; i >= 0; i--) {
reversedByte |= ((input & 1) << i);
input >>= 1;
}
return reversedByte;
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const algorithm = args[0];
switch (algorithm) {
case "CRC-8":
return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x0);
case "CRC-8/CDMA2000":
return this.calculateCRC8(input, 0x9B, 0xFF, false, false, 0x0);
case "CRC-8/DARC":
return this.calculateCRC8(input, 0x39, 0x0, true, true, 0x0);
case "CRC-8/DVB-S2":
return this.calculateCRC8(input, 0xD5, 0x0, false, false, 0x0);
case "CRC-8/EBU":
return this.calculateCRC8(input, 0x1D, 0xFF, true, true, 0x0);
case "CRC-8/I-CODE":
return this.calculateCRC8(input, 0x1D, 0xFD, false, false, 0x0);
case "CRC-8/ITU":
return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x55);
case "CRC-8/MAXIM":
return this.calculateCRC8(input, 0x31, 0x0, true, true, 0x0);
case "CRC-8/ROHC":
return this.calculateCRC8(input, 0x7, 0xFF, true, true, 0x0);
case "CRC-8/WCDMA":
return this.calculateCRC8(input, 0x9B, 0x0, true, true, 0x0);
default:
throw new OperationError("Unknown checksum algorithm");
}
}
}
export default CRC8Checksum;

1110
src/core/operations/CRCChecksum.mjs Normal file
View File

File diff suppressed because it is too large Load Diff

90
src/core/operations/ContainImage.mjs
View File

@ -9,13 +9,18 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import {
Jimp,
JimpMime,
ResizeStrategy,
HorizontalAlign,
VerticalAlign,
} from "jimp";
/** /**
* Contain Image operation * Contain Image operation
*/ */
class ContainImage extends Operation { class ContainImage extends Operation {
/** /**
* ContainImage constructor * ContainImage constructor
*/ */
@ -24,7 +29,8 @@ class ContainImage extends Operation {
this.name = "Contain Image"; this.name = "Contain Image";
this.module = "Image"; this.module = "Image";
this.description = "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed."; this.description =
"Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed.";
this.infoURL = ""; this.infoURL = "";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -34,33 +40,25 @@ class ContainImage extends Operation {
name: "Width", name: "Width",
type: "number", type: "number",
value: 100, value: 100,
min: 1 min: 1,
}, },
{ {
name: "Height", name: "Height",
type: "number", type: "number",
value: 100, value: 100,
min: 1 min: 1,
}, },
{ {
name: "Horizontal align", name: "Horizontal align",
type: "option", type: "option",
value: [ value: ["Left", "Center", "Right"],
"Left", defaultIndex: 1,
"Center",
"Right"
],
defaultIndex: 1
}, },
{ {
name: "Vertical align", name: "Vertical align",
type: "option", type: "option",
value: [ value: ["Top", "Middle", "Bottom"],
"Top", defaultIndex: 1,
"Middle",
"Bottom"
],
defaultIndex: 1
}, },
{ {
name: "Resizing algorithm", name: "Resizing algorithm",
@ -70,15 +68,15 @@ class ContainImage extends Operation {
"Bilinear", "Bilinear",
"Bicubic", "Bicubic",
"Hermite", "Hermite",
"Bezier" "Bezier",
], ],
defaultIndex: 1 defaultIndex: 1,
}, },
{ {
name: "Opaque background", name: "Opaque background",
type: "boolean", type: "boolean",
value: true value: true,
} },
]; ];
} }
@ -91,20 +89,20 @@ class ContainImage extends Operation {
const [width, height, hAlign, vAlign, alg, opaqueBg] = args; const [width, height, hAlign, vAlign, alg, opaqueBg] = args;
const resizeMap = { const resizeMap = {
"Nearest Neighbour": Jimp.RESIZE_NEAREST_NEIGHBOR, "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
"Bilinear": Jimp.RESIZE_BILINEAR, Bilinear: ResizeStrategy.BILINEAR,
"Bicubic": Jimp.RESIZE_BICUBIC, Bicubic: ResizeStrategy.BICUBIC,
"Hermite": Jimp.RESIZE_HERMITE, Hermite: ResizeStrategy.HERMITE,
"Bezier": Jimp.RESIZE_BEZIER Bezier: ResizeStrategy.BEZIER,
}; };
const alignMap = { const alignMap = {
"Left": Jimp.HORIZONTAL_ALIGN_LEFT, Left: HorizontalAlign.LEFT,
"Center": Jimp.HORIZONTAL_ALIGN_CENTER, Center: HorizontalAlign.CENTER,
"Right": Jimp.HORIZONTAL_ALIGN_RIGHT, Right: HorizontalAlign.RIGHT,
"Top": Jimp.VERTICAL_ALIGN_TOP, Top: VerticalAlign.TOP,
"Middle": Jimp.VERTICAL_ALIGN_MIDDLE, Middle: VerticalAlign.MIDDLE,
"Bottom": Jimp.VERTICAL_ALIGN_BOTTOM Bottom: VerticalAlign.BOTTOM,
}; };
if (!isImage(input)) { if (!isImage(input)) {
@ -117,22 +115,35 @@ class ContainImage extends Operation {
} catch (err) { } catch (err) {
throw new OperationError(`Error loading image. (${err})`); throw new OperationError(`Error loading image. (${err})`);
} }
const originalMime = image.mime;
try { try {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Containing image..."); self.sendStatusMessage("Containing image...");
image.contain(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]); image.contain({
w: width,
h: height,
align: alignMap[hAlign] | alignMap[vAlign],
mode: resizeMap[alg],
});
if (opaqueBg) { if (opaqueBg) {
const newImage = await Jimp.read(width, height, 0x000000FF); const newImage = new Jimp({
newImage.blit(image, 0, 0); width,
image = newImage; height,
color: 0x000000ff,
});
image = newImage.blit({
src: image,
x: 0,
y: 0,
});
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (originalMime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(originalMime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -156,7 +167,6 @@ class ContainImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default ContainImage; export default ContainImage;

72
src/core/operations/ConvertImageFormat.mjs
View File

@ -8,13 +8,12 @@ import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs"; import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime, PNGFilterType } from "jimp";
/** /**
* Convert Image Format operation * Convert Image Format operation
*/ */
class ConvertImageFormat extends Operation { class ConvertImageFormat extends Operation {
/** /**
* ConvertImageFormat constructor * ConvertImageFormat constructor
*/ */
@ -23,7 +22,8 @@ class ConvertImageFormat extends Operation {
this.name = "Convert Image Format"; this.name = "Convert Image Format";
this.module = "Image"; this.module = "Image";
this.description = "Converts an image between different formats. Supported formats:<br><ul><li>Joint Photographic Experts Group (JPEG)</li><li>Portable Network Graphics (PNG)</li><li>Bitmap (BMP)</li><li>Tagged Image File Format (TIFF)</li></ul><br>Note: GIF files are supported for input, but cannot be outputted."; this.description =
"Converts an image between different formats. Supported formats:<br><ul><li>Joint Photographic Experts Group (JPEG)</li><li>Portable Network Graphics (PNG)</li><li>Bitmap (BMP)</li><li>Tagged Image File Format (TIFF)</li></ul><br>Note: GIF files are supported for input, but cannot be outputted.";
this.infoURL = "https://wikipedia.org/wiki/Image_file_formats"; this.infoURL = "https://wikipedia.org/wiki/Image_file_formats";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -32,39 +32,27 @@ class ConvertImageFormat extends Operation {
{ {
name: "Output Format", name: "Output Format",
type: "option", type: "option",
value: [ value: ["JPEG", "PNG", "BMP", "TIFF"],
"JPEG",
"PNG",
"BMP",
"TIFF"
]
}, },
{ {
name: "JPEG Quality", name: "JPEG Quality",
type: "number", type: "number",
value: 80, value: 80,
min: 1, min: 1,
max: 100 max: 100,
}, },
{ {
name: "PNG Filter Type", name: "PNG Filter Type",
type: "option", type: "option",
value: [ value: ["Auto", "None", "Sub", "Up", "Average", "Paeth"],
"Auto",
"None",
"Sub",
"Up",
"Average",
"Paeth"
]
}, },
{ {
name: "PNG Deflate Level", name: "PNG Deflate Level",
type: "number", type: "number",
value: 9, value: 9,
min: 0, min: 0,
max: 9 max: 9,
} },
]; ];
} }
@ -76,19 +64,19 @@ class ConvertImageFormat extends Operation {
async run(input, args) { async run(input, args) {
const [format, jpegQuality, pngFilterType, pngDeflateLevel] = args; const [format, jpegQuality, pngFilterType, pngDeflateLevel] = args;
const formatMap = { const formatMap = {
"JPEG": Jimp.MIME_JPEG, JPEG: JimpMime.jpeg,
"PNG": Jimp.MIME_PNG, PNG: JimpMime.png,
"BMP": Jimp.MIME_BMP, BMP: JimpMime.bmp,
"TIFF": Jimp.MIME_TIFF TIFF: JimpMime.tiff,
}; };
const pngFilterMap = { const pngFilterMap = {
"Auto": Jimp.PNG_FILTER_AUTO, Auto: PNGFilterType.AUTO,
"None": Jimp.PNG_FILTER_NONE, None: PNGFilterType.NONE,
"Sub": Jimp.PNG_FILTER_SUB, Sub: PNGFilterType.SUB,
"Up": Jimp.PNG_FILTER_UP, Up: PNGFilterType.UP,
"Average": Jimp.PNG_FILTER_AVERAGE, Average: PNGFilterType.AVERAGE,
"Paeth": Jimp.PNG_FILTER_PATH Paeth: PNGFilterType.PATH,
}; };
const mime = formatMap[format]; const mime = formatMap[format];
@ -103,18 +91,25 @@ class ConvertImageFormat extends Operation {
throw new OperationError(`Error opening image file. (${err})`); throw new OperationError(`Error opening image file. (${err})`);
} }
try { try {
switch (format) { let buffer;
case "JPEG": switch (mime) {
image.quality(jpegQuality); case JimpMime.jpeg:
buffer = await image.getBuffer(mime, {
quality: jpegQuality,
});
break; break;
case "PNG": case JimpMime.png:
image.filterType(pngFilterMap[pngFilterType]); buffer = await image.getBuffer(mime, {
image.deflateLevel(pngDeflateLevel); filterType: pngFilterMap[pngFilterType],
deflateLevel: pngDeflateLevel,
});
break;
default:
buffer = await image.getBuffer(mime);
break; break;
} }
const imageBuffer = await image.getBufferAsync(mime); return buffer.buffer;
return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error converting image format. (${err})`); throw new OperationError(`Error converting image format. (${err})`);
} }
@ -137,7 +132,6 @@ class ConvertImageFormat extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default ConvertImageFormat; export default ConvertImageFormat;

13
src/core/operations/ConvertLeetSpeak.mjs
View File

@ -18,7 +18,7 @@ class ConvertLeetSpeak extends Operation {
this.name = "Convert Leet Speak"; this.name = "Convert Leet Speak";
this.module = "Default"; this.module = "Default";
this.description = "Converts to and from Leet Speak"; this.description = "Converts to and from Leet Speak.";
this.infoURL = "https://wikipedia.org/wiki/Leet"; this.infoURL = "https://wikipedia.org/wiki/Leet";
this.inputType = "string"; this.inputType = "string";
this.outputType = "string"; this.outputType = "string";
@ -39,13 +39,16 @@ class ConvertLeetSpeak extends Operation {
*/ */
run(input, args) { run(input, args) {
const direction = args[0]; const direction = args[0];
if (direction === "To Leet Speak") { if (direction === "To Leet Speak") {
return input.replace(/[abcdefghijklmnopqrstuvwxyz]/gi, char => { return input.replace(/[a-z]/gi, char => {
return toLeetMap[char.toLowerCase()] || char; const leetChar = toLeetMap[char.toLowerCase()] || char;
return char === char.toUpperCase() ? leetChar.toUpperCase() : leetChar;
}); });
} else if (direction === "From Leet Speak") { } else if (direction === "From Leet Speak") {
return input.replace(/[48cd3f6h1jklmn0pqr57uvwxyz]/g, char => { return input.replace(/[48cd3f6h1jklmn0pqr57uvwxyz]/gi, char => {
return fromLeetMap[char] || char; const normalChar = fromLeetMap[char] || char;
return normalChar;
}); });
} }
} }

76
src/core/operations/CoverImage.mjs
View File

@ -9,13 +9,18 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import jimp from "jimp/es/index.js"; import {
Jimp,
JimpMime,
ResizeStrategy,
HorizontalAlign,
VerticalAlign,
} from "jimp";
/** /**
* Cover Image operation * Cover Image operation
*/ */
class CoverImage extends Operation { class CoverImage extends Operation {
/** /**
* CoverImage constructor * CoverImage constructor
*/ */
@ -24,7 +29,8 @@ class CoverImage extends Operation {
this.name = "Cover Image"; this.name = "Cover Image";
this.module = "Image"; this.module = "Image";
this.description = "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped."; this.description =
"Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
this.infoURL = ""; this.infoURL = "";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -34,33 +40,25 @@ class CoverImage extends Operation {
name: "Width", name: "Width",
type: "number", type: "number",
value: 100, value: 100,
min: 1 min: 1,
}, },
{ {
name: "Height", name: "Height",
type: "number", type: "number",
value: 100, value: 100,
min: 1 min: 1,
}, },
{ {
name: "Horizontal align", name: "Horizontal align",
type: "option", type: "option",
value: [ value: ["Left", "Center", "Right"],
"Left", defaultIndex: 1,
"Center",
"Right"
],
defaultIndex: 1
}, },
{ {
name: "Vertical align", name: "Vertical align",
type: "option", type: "option",
value: [ value: ["Top", "Middle", "Bottom"],
"Top", defaultIndex: 1,
"Middle",
"Bottom"
],
defaultIndex: 1
}, },
{ {
name: "Resizing algorithm", name: "Resizing algorithm",
@ -70,10 +68,10 @@ class CoverImage extends Operation {
"Bilinear", "Bilinear",
"Bicubic", "Bicubic",
"Hermite", "Hermite",
"Bezier" "Bezier",
], ],
defaultIndex: 1 defaultIndex: 1,
} },
]; ];
} }
@ -86,20 +84,20 @@ class CoverImage extends Operation {
const [width, height, hAlign, vAlign, alg] = args; const [width, height, hAlign, vAlign, alg] = args;
const resizeMap = { const resizeMap = {
"Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR, "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
"Bilinear": jimp.RESIZE_BILINEAR, Bilinear: ResizeStrategy.BILINEAR,
"Bicubic": jimp.RESIZE_BICUBIC, Bicubic: ResizeStrategy.BICUBIC,
"Hermite": jimp.RESIZE_HERMITE, Hermite: ResizeStrategy.HERMITE,
"Bezier": jimp.RESIZE_BEZIER Bezier: ResizeStrategy.BEZIER,
}; };
const alignMap = { const alignMap = {
"Left": jimp.HORIZONTAL_ALIGN_LEFT, Left: HorizontalAlign.LEFT,
"Center": jimp.HORIZONTAL_ALIGN_CENTER, Center: HorizontalAlign.CENTER,
"Right": jimp.HORIZONTAL_ALIGN_RIGHT, Right: HorizontalAlign.RIGHT,
"Top": jimp.VERTICAL_ALIGN_TOP, Top: VerticalAlign.TOP,
"Middle": jimp.VERTICAL_ALIGN_MIDDLE, Middle: VerticalAlign.MIDDLE,
"Bottom": jimp.VERTICAL_ALIGN_BOTTOM Bottom: VerticalAlign.BOTTOM,
}; };
if (!isImage(input)) { if (!isImage(input)) {
@ -108,19 +106,24 @@ class CoverImage extends Operation {
let image; let image;
try { try {
image = await jimp.read(input); image = await Jimp.read(input);
} catch (err) { } catch (err) {
throw new OperationError(`Error loading image. (${err})`); throw new OperationError(`Error loading image. (${err})`);
} }
try { try {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Covering image..."); self.sendStatusMessage("Covering image...");
image.cover(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]); image.cover({
w: width,
h: height,
align: alignMap[hAlign] | alignMap[vAlign],
mode: resizeMap[alg],
});
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -144,7 +147,6 @@ class CoverImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default CoverImage; export default CoverImage;

56
src/core/operations/CropImage.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Crop Image operation * Crop Image operation
*/ */
class CropImage extends Operation { class CropImage extends Operation {
/** /**
* CropImage constructor * CropImage constructor
*/ */
@ -24,7 +23,8 @@ class CropImage extends Operation {
this.name = "Crop Image"; this.name = "Crop Image";
this.module = "Image"; this.module = "Image";
this.description = "Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image."; this.description =
"Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image.";
this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)"; this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -34,30 +34,30 @@ class CropImage extends Operation {
name: "X Position", name: "X Position",
type: "number", type: "number",
value: 0, value: 0,
min: 0 min: 0,
}, },
{ {
name: "Y Position", name: "Y Position",
type: "number", type: "number",
value: 0, value: 0,
min: 0 min: 0,
}, },
{ {
name: "Width", name: "Width",
type: "number", type: "number",
value: 10, value: 10,
min: 1 min: 1,
}, },
{ {
name: "Height", name: "Height",
type: "number", type: "number",
value: 10, value: 10,
min: 1 min: 1,
}, },
{ {
name: "Autocrop", name: "Autocrop",
type: "boolean", type: "boolean",
value: false value: false,
}, },
{ {
name: "Autocrop tolerance (%)", name: "Autocrop tolerance (%)",
@ -65,24 +65,24 @@ class CropImage extends Operation {
value: 0.02, value: 0.02,
min: 0, min: 0,
max: 100, max: 100,
step: 0.01 step: 0.01,
}, },
{ {
name: "Only autocrop frames", name: "Only autocrop frames",
type: "boolean", type: "boolean",
value: true value: true,
}, },
{ {
name: "Symmetric autocrop", name: "Symmetric autocrop",
type: "boolean", type: "boolean",
value: false value: false,
}, },
{ {
name: "Autocrop keep border (px)", name: "Autocrop keep border (px)",
type: "number", type: "number",
value: 0, value: 0,
min: 0 min: 0,
} },
]; ];
} }
@ -92,7 +92,17 @@ class CropImage extends Operation {
* @returns {byteArray} * @returns {byteArray}
*/ */
async run(input, args) { async run(input, args) {
const [xPos, yPos, width, height, autocrop, autoTolerance, autoFrames, autoSymmetric, autoBorder] = args; const [
xPos,
yPos,
width,
height,
autocrop,
autoTolerance,
autoFrames,
autoSymmetric,
autoBorder,
] = args;
if (!isImage(input)) { if (!isImage(input)) {
throw new OperationError("Invalid file type."); throw new OperationError("Invalid file type.");
} }
@ -108,20 +118,25 @@ class CropImage extends Operation {
self.sendStatusMessage("Cropping image..."); self.sendStatusMessage("Cropping image...");
if (autocrop) { if (autocrop) {
image.autocrop({ image.autocrop({
tolerance: (autoTolerance / 100), tolerance: autoTolerance / 100,
cropOnlyFrames: autoFrames, cropOnlyFrames: autoFrames,
cropSymmetric: autoSymmetric, cropSymmetric: autoSymmetric,
leaveBorder: autoBorder leaveBorder: autoBorder,
}); });
} else { } else {
image.crop(xPos, yPos, width, height); image.crop({
x: xPos,
y: yPos,
w: width,
h: height,
});
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -145,7 +160,6 @@ class CropImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default CropImage; export default CropImage;

5
src/core/operations/DESDecrypt.mjs
View File

@ -22,7 +22,7 @@ class DESDecrypt extends Operation {
this.name = "DES Decrypt"; this.name = "DES Decrypt";
this.module = "Ciphers"; this.module = "Ciphers";
this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes (192 bits).<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used as a default."; this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used as a default.";
this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard"; this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard";
this.inputType = "string"; this.inputType = "string";
this.outputType = "string"; this.outputType = "string";
@ -72,8 +72,7 @@ class DESDecrypt extends Operation {
if (key.length !== 8) { if (key.length !== 8) {
throw new OperationError(`Invalid key length: ${key.length} bytes throw new OperationError(`Invalid key length: ${key.length} bytes
DES uses a key length of 8 bytes (64 bits). DES uses a key length of 8 bytes (64 bits).`);
Triple DES uses a key length of 24 bytes (192 bits).`);
} }
if (iv.length !== 8 && mode !== "ECB") { if (iv.length !== 8 && mode !== "ECB") {
throw new OperationError(`Invalid IV length: ${iv.length} bytes throw new OperationError(`Invalid IV length: ${iv.length} bytes

5
src/core/operations/DESEncrypt.mjs
View File

@ -22,7 +22,7 @@ class DESEncrypt extends Operation {
this.name = "DES Encrypt"; this.name = "DES Encrypt";
this.module = "Ciphers"; this.module = "Ciphers";
this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes (192 bits).<br><br>You can generate a password-based key using one of the KDF operations.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used."; this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br><br>You can generate a password-based key using one of the KDF operations.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used.";
this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard"; this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard";
this.inputType = "string"; this.inputType = "string";
this.outputType = "string"; this.outputType = "string";
@ -70,8 +70,7 @@ class DESEncrypt extends Operation {
if (key.length !== 8) { if (key.length !== 8) {
throw new OperationError(`Invalid key length: ${key.length} bytes throw new OperationError(`Invalid key length: ${key.length} bytes
DES uses a key length of 8 bytes (64 bits). DES uses a key length of 8 bytes (64 bits).`);
Triple DES uses a key length of 24 bytes (192 bits).`);
} }
if (iv.length !== 8 && mode !== "ECB") { if (iv.length !== 8 && mode !== "ECB") {
throw new OperationError(`Invalid IV length: ${iv.length} bytes throw new OperationError(`Invalid IV length: ${iv.length} bytes

16
src/core/operations/DitherImage.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Image Dither operation * Image Dither operation
*/ */
class DitherImage extends Operation { class DitherImage extends Operation {
/** /**
* DitherImage constructor * DitherImage constructor
*/ */
@ -51,17 +50,19 @@ class DitherImage extends Operation {
try { try {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Applying dither to image..."); self.sendStatusMessage("Applying dither to image...");
image.dither565(); image.dither();
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error applying dither to image. (${err})`); throw new OperationError(
`Error applying dither to image. (${err})`,
);
} }
} }
@ -81,7 +82,6 @@ class DitherImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default DitherImage; export default DitherImage;

11
src/core/operations/ECDSAVerify.mjs
View File

@ -9,6 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
import { fromBase64 } from "../lib/Base64.mjs"; import { fromBase64 } from "../lib/Base64.mjs";
import { toHexFast } from "../lib/Hex.mjs"; import { toHexFast } from "../lib/Hex.mjs";
import r from "jsrsasign"; import r from "jsrsasign";
import Utils from "../Utils.mjs";
/** /**
* ECDSA Verify operation * ECDSA Verify operation
@ -59,6 +60,11 @@ class ECDSAVerify extends Operation {
name: "Message", name: "Message",
type: "text", type: "text",
value: "" value: ""
},
{
name: "Message format",
type: "option",
value: ["Raw", "Hex", "Base64"]
} }
]; ];
} }
@ -70,7 +76,7 @@ class ECDSAVerify extends Operation {
*/ */
run(input, args) { run(input, args) {
let inputFormat = args[0]; let inputFormat = args[0];
const [, mdAlgo, keyPem, msg] = args; const [, mdAlgo, keyPem, msg, msgFormat] = args;
if (keyPem.replace("-----BEGIN PUBLIC KEY-----", "").length === 0) { if (keyPem.replace("-----BEGIN PUBLIC KEY-----", "").length === 0) {
throw new OperationError("Please enter a public key."); throw new OperationError("Please enter a public key.");
@ -145,7 +151,8 @@ class ECDSAVerify extends Operation {
throw new OperationError("Provided key is not a public key."); throw new OperationError("Provided key is not a public key.");
} }
sig.init(key); sig.init(key);
sig.updateString(msg); const messageStr = Utils.convertToByteString(msg, msgFormat);
sig.updateString(messageStr);
const result = sig.verify(signatureASN1Hex); const result = sig.verify(signatureASN1Hex);
return result ? "Verified OK" : "Verification Failure"; return result ? "Verified OK" : "Verification Failure";
} }

17
src/core/operations/EscapeUnicodeCharacters.mjs
View File

@ -44,23 +44,6 @@ class EscapeUnicodeCharacters extends Operation {
"value": true "value": true
} }
]; ];
this.checks = [
{
pattern: "\\\\u(?:[\\da-f]{4,6})",
flags: "i",
args: ["\\u"]
},
{
pattern: "%u(?:[\\da-f]{4,6})",
flags: "i",
args: ["%u"]
},
{
pattern: "U\\+(?:[\\da-f]{4,6})",
flags: "i",
args: ["U+"]
}
];
} }
/** /**

11
src/core/operations/ExtractDomains.mjs
View File

@ -5,7 +5,7 @@
*/ */
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
import { search, DOMAIN_REGEX } from "../lib/Extract.mjs"; import { search, DOMAIN_REGEX, DMARC_DOMAIN_REGEX } from "../lib/Extract.mjs";
import { caseInsensitiveSort } from "../lib/Sort.mjs"; import { caseInsensitiveSort } from "../lib/Sort.mjs";
/** /**
@ -39,6 +39,11 @@ class ExtractDomains extends Operation {
name: "Unique", name: "Unique",
type: "boolean", type: "boolean",
value: false value: false
},
{
name: "Underscore (DMARC, DKIM, etc)",
type: "boolean",
value: false
} }
]; ];
} }
@ -49,11 +54,11 @@ class ExtractDomains extends Operation {
* @returns {string} * @returns {string}
*/ */
run(input, args) { run(input, args) {
const [displayTotal, sort, unique] = args; const [displayTotal, sort, unique, dmarc] = args;
const results = search( const results = search(
input, input,
DOMAIN_REGEX, dmarc ? DMARC_DOMAIN_REGEX : DOMAIN_REGEX,
null, null,
sort ? caseInsensitiveSort : null, sort ? caseInsensitiveSort : null,
unique unique

2
src/core/operations/ExtractEmailAddresses.mjs
View File

@ -51,7 +51,7 @@ class ExtractEmailAddresses extends Operation {
run(input, args) { run(input, args) {
const [displayTotal, sort, unique] = args, const [displayTotal, sort, unique] = args,
// email regex from: https://www.regextester.com/98066 // email regex from: https://www.regextester.com/98066
regex = /(?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9](?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9-]*[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9])?\.)+[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9](?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9-]*[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}\])/ig; regex = /(?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9](?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9-]*[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9])?\.)+[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9](?:[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9-]*[\u00A0-\uD7FF\uE000-\uFFFFa-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\])/ig;
const results = search( const results = search(
input, input,

18
src/core/operations/ExtractIPAddresses.mjs
View File

@ -21,7 +21,7 @@ class ExtractIPAddresses extends Operation {
this.name = "Extract IP addresses"; this.name = "Extract IP addresses";
this.module = "Regex"; this.module = "Regex";
this.description = "Extracts all IPv4 and IPv6 addresses.<br><br>Warning: Given a string <code>710.65.0.456</code>, this will match <code>10.65.0.45</code> so always check the original input!"; this.description = "Extracts all IPv4 and IPv6 addresses.<br><br>Warning: Given a string <code>1.2.3.4.5.6.7.8</code>, this will match <code>1.2.3.4 and 5.6.7.8</code> so always check the original input!";
this.inputType = "string"; this.inputType = "string";
this.outputType = "string"; this.outputType = "string";
this.args = [ this.args = [
@ -65,7 +65,21 @@ class ExtractIPAddresses extends Operation {
*/ */
run(input, args) { run(input, args) {
const [includeIpv4, includeIpv6, removeLocal, displayTotal, sort, unique] = args, const [includeIpv4, includeIpv6, removeLocal, displayTotal, sort, unique] = args,
ipv4 = "(?:(?:\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d|\\d)(?:\\/\\d{1,2})?",
// IPv4 decimal groups can have values 0 to 255. To construct a regex the following sub-regex is reused:
ipv4DecimalByte = "(?:25[0-5]|2[0-4]\\d|1?[0-9]\\d|\\d)",
ipv4OctalByte = "(?:0[1-3]?[0-7]{1,2})",
// Look behind and ahead will be used to exclude matches with additional decimal digits left and right of IP address
lookBehind = "(?<!\\d)",
lookAhead = "(?!\\d)",
// Each variant requires exactly 4 groups with literal . between.
ipv4Decimal = "(?:" + lookBehind + ipv4DecimalByte + "\\.){3}" + "(?:" + ipv4DecimalByte + lookAhead + ")",
ipv4Octal = "(?:" + lookBehind + ipv4OctalByte + "\\.){3}" + "(?:" + ipv4OctalByte + lookAhead + ")",
// Then we allow IPv4 addresses to be expressed either entirely in decimal or entirely in Octal
ipv4 = "(?:" + ipv4Decimal + "|" + ipv4Octal + ")",
ipv6 = "((?=.*::)(?!.*::.+::)(::)?([\\dA-F]{1,4}:(:|\\b)|){5}|([\\dA-F]{1,4}:){6})(([\\dA-F]{1,4}((?!\\3)::|:\\b|(?![\\dA-F])))|(?!\\2\\3)){2}"; ipv6 = "((?=.*::)(?!.*::.+::)(::)?([\\dA-F]{1,4}:(:|\\b)|){5}|([\\dA-F]{1,4}:){6})(([\\dA-F]{1,4}((?!\\3)::|:\\b|(?![\\dA-F])))|(?!\\2\\3)){2}";
let ips = ""; let ips = "";

28
src/core/operations/ExtractLSB.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import Utils from "../Utils.mjs"; import Utils from "../Utils.mjs";
import { fromBinary } from "../lib/Binary.mjs"; import { fromBinary } from "../lib/Binary.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp } from "jimp";
/** /**
* Extract LSB operation * Extract LSB operation
*/ */
class ExtractLSB extends Operation { class ExtractLSB extends Operation {
/** /**
* ExtractLSB constructor * ExtractLSB constructor
*/ */
@ -24,8 +23,10 @@ class ExtractLSB extends Operation {
this.name = "Extract LSB"; this.name = "Extract LSB";
this.module = "Image"; this.module = "Image";
this.description = "Extracts the Least Significant Bit data from each pixel in an image. This is a common way to hide data in Steganography."; this.description =
this.infoURL = "https://wikipedia.org/wiki/Bit_numbering#Least_significant_bit_in_digital_steganography"; "Extracts the Least Significant Bit data from each pixel in an image. This is a common way to hide data in Steganography.";
this.infoURL =
"https://wikipedia.org/wiki/Bit_numbering#Least_significant_bit_in_digital_steganography";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "byteArray"; this.outputType = "byteArray";
this.args = [ this.args = [
@ -57,8 +58,8 @@ class ExtractLSB extends Operation {
{ {
name: "Bit", name: "Bit",
type: "number", type: "number",
value: 0 value: 0,
} },
]; ];
} }
@ -68,21 +69,27 @@ class ExtractLSB extends Operation {
* @returns {byteArray} * @returns {byteArray}
*/ */
async run(input, args) { async run(input, args) {
if (!isImage(input)) throw new OperationError("Please enter a valid image file."); if (!isImage(input))
throw new OperationError("Please enter a valid image file.");
const bit = 7 - args.pop(), const bit = 7 - args.pop(),
pixelOrder = args.pop(), pixelOrder = args.pop(),
colours = args.filter(option => option !== "").map(option => COLOUR_OPTIONS.indexOf(option)), colours = args
.filter((option) => option !== "")
.map((option) => COLOUR_OPTIONS.indexOf(option)),
parsedImage = await Jimp.read(input), parsedImage = await Jimp.read(input),
width = parsedImage.bitmap.width, width = parsedImage.bitmap.width,
height = parsedImage.bitmap.height, height = parsedImage.bitmap.height,
rgba = parsedImage.bitmap.data; rgba = parsedImage.bitmap.data;
if (bit < 0 || bit > 7) { if (bit < 0 || bit > 7) {
throw new OperationError("Error: Bit argument must be between 0 and 7"); throw new OperationError(
"Error: Bit argument must be between 0 and 7",
);
} }
let i, combinedBinary = ""; let i,
combinedBinary = "";
if (pixelOrder === "Row") { if (pixelOrder === "Row") {
for (i = 0; i < rgba.length; i += 4) { for (i = 0; i < rgba.length; i += 4) {
@ -106,7 +113,6 @@ class ExtractLSB extends Operation {
return fromBinary(combinedBinary); return fromBinary(combinedBinary);
} }
} }
const COLOUR_OPTIONS = ["R", "G", "B", "A"]; const COLOUR_OPTIONS = ["R", "G", "B", "A"];

20
src/core/operations/ExtractRGBA.mjs
View File

@ -7,7 +7,7 @@
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs"; import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp } from "jimp";
import { RGBA_DELIM_OPTIONS } from "../lib/Delim.mjs"; import { RGBA_DELIM_OPTIONS } from "../lib/Delim.mjs";
@ -15,7 +15,6 @@ import {RGBA_DELIM_OPTIONS} from "../lib/Delim.mjs";
* Extract RGBA operation * Extract RGBA operation
*/ */
class ExtractRGBA extends Operation { class ExtractRGBA extends Operation {
/** /**
* ExtractRGBA constructor * ExtractRGBA constructor
*/ */
@ -24,7 +23,8 @@ class ExtractRGBA extends Operation {
this.name = "Extract RGBA"; this.name = "Extract RGBA";
this.module = "Image"; this.module = "Image";
this.description = "Extracts each pixel's RGBA value in an image. These are sometimes used in Steganography to hide text or data."; this.description =
"Extracts each pixel's RGBA value in an image. These are sometimes used in Steganography to hide text or data.";
this.infoURL = "https://wikipedia.org/wiki/RGBA_color_space"; this.infoURL = "https://wikipedia.org/wiki/RGBA_color_space";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "string"; this.outputType = "string";
@ -32,13 +32,13 @@ class ExtractRGBA extends Operation {
{ {
name: "Delimiter", name: "Delimiter",
type: "editableOption", type: "editableOption",
value: RGBA_DELIM_OPTIONS value: RGBA_DELIM_OPTIONS,
}, },
{ {
name: "Include Alpha", name: "Include Alpha",
type: "boolean", type: "boolean",
value: true value: true,
} },
]; ];
} }
@ -48,18 +48,20 @@ class ExtractRGBA extends Operation {
* @returns {string} * @returns {string}
*/ */
async run(input, args) { async run(input, args) {
if (!isImage(input)) throw new OperationError("Please enter a valid image file."); if (!isImage(input))
throw new OperationError("Please enter a valid image file.");
const delimiter = args[0], const delimiter = args[0],
includeAlpha = args[1], includeAlpha = args[1],
parsedImage = await Jimp.read(input); parsedImage = await Jimp.read(input);
let bitmap = parsedImage.bitmap.data; let bitmap = parsedImage.bitmap.data;
bitmap = includeAlpha ? bitmap : bitmap.filter((val, idx) => idx % 4 !== 3); bitmap = includeAlpha ?
bitmap :
bitmap.filter((val, idx) => idx % 4 !== 3);
return bitmap.join(delimiter); return bitmap.join(delimiter);
} }
} }
export default ExtractRGBA; export default ExtractRGBA;

80
src/core/operations/FlaskSessionDecode.mjs Normal file
View File

@ -0,0 +1,80 @@
/**
* @author ThePlayer372-FR []
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import { fromBase64 } from "../lib/Base64.mjs";
/**
* Flask Session Decode operation
*/
class FlaskSessionDecode extends Operation {
/**
* FlaskSessionDecode constructor
*/
constructor() {
super();
this.name = "Flask Session Decode";
this.module = "Crypto";
this.description = "Decodes the payload of a Flask session cookie (itsdangerous) into JSON.";
this.inputType = "string";
this.outputType = "JSON";
this.args = [
{
name: "View TimeStamp",
type: "boolean",
value: false
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {Object[]}
*/
run(input, args) {
input = input.trim();
const parts = input.split(".");
if (parts.length !== 3) {
throw new OperationError("Invalid Flask token format. Expected payload.timestamp.signature");
}
const payloadB64 = parts[0];
const time = parts[1];
const timeB64 = time.replace(/-/g, "+").replace(/_/g, "/");
const binary = fromBase64(timeB64);
const bytes = new Uint8Array(4);
for (let i = 0; i < 4; i++) {
bytes[i] = binary.charCodeAt(i);
}
const view = new DataView(bytes.buffer);
const timestamp = view.getInt32(0, false);
const base64 = payloadB64.replace(/-/g, "+").replace(/_/g, "/");
const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
let payloadJson;
try {
payloadJson = fromBase64(padded);
} catch (e) {
throw new OperationError("Invalid Base64 payload");
}
try {
let data = JSON.parse(payloadJson);
if (args[0]) {
data = {payload: data, timestamp: timestamp};
}
return data;
} catch (e) {
throw new OperationError("Unable to decode JSON payload: " + e.message);
}
}
}
export default FlaskSessionDecode;

89
src/core/operations/FlaskSessionSign.mjs Normal file
View File

@ -0,0 +1,89 @@
/**
* @author ThePlayer372-FR []
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import CryptoApi from "crypto-api/src/crypto-api.mjs";
import Utils from "../Utils.mjs";
import { toBase64 } from "../lib/Base64.mjs";
import OperationError from "../errors/OperationError.mjs";
/**
* Flask Session Sign operation
*/
class FlaskSessionSign extends Operation {
/**
* FlaskSessionSign constructor
*/
constructor() {
super();
this.name = "Flask Session Sign";
this.module = "Crypto";
this.description = "Signs a JSON payload to produce a Flask session cookie (itsdangerous HMAC).";
this.inputType = "JSON";
this.outputType = "string";
this.args = [
{
name: "Key",
type: "toggleString",
value: "",
toggleValues: ["Hex", "Decimal", "Binary", "Base64", "UTF8", "Latin1"]
},
{
name: "Salt",
type: "toggleString",
value: "cookie-session",
toggleValues: ["UTF8", "Hex", "Decimal", "Binary", "Base64", "Latin1"]
},
{
name: "Algorithm",
type: "option",
value: ["sha1", "sha256"],
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
if (!args[0].string) {
throw new OperationError("Secret key required");
}
const key = Utils.convertToByteString(args[0].string, args[0].option);
const salt = Utils.convertToByteString(args[1].string || "cookie-session", args[1].option);
const algorithm = args[2] || "sha1";
const payloadB64 = toBase64(Utils.strToByteArray(JSON.stringify(input)));
const payload = payloadB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
const derivedKey = CryptoApi.getHmac(key, CryptoApi.getHasher(algorithm));
derivedKey.update(salt);
const currentTimeStamp = Math.ceil(Date.now() / 1000);
const buffer = new ArrayBuffer(4);
const view = new DataView(buffer);
view.setInt32(0, currentTimeStamp, false);
const bytes = new Uint8Array(buffer);
let binary = "";
bytes.forEach(b => binary += String.fromCharCode(b));
const timeB64 = toBase64(Utils.strToByteArray(binary));
const time = timeB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
const data = Utils.convertToByteString(payload + "." + time, "utf8");
const sign = CryptoApi.getHmac(derivedKey.finalize(), CryptoApi.getHasher(algorithm));
sign.update(data);
const signB64 = toBase64(sign.finalize());
const sign64 = signB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
return payload + "." + time + "." + sign64;
}
}
export default FlaskSessionSign;

136
src/core/operations/FlaskSessionVerify.mjs Normal file
View File

@ -0,0 +1,136 @@
/**
* @author ThePlayer372-FR []
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import CryptoApi from "crypto-api/src/crypto-api.mjs";
import Utils from "../Utils.mjs";
import { toBase64, fromBase64 } from "../lib/Base64.mjs";
/**
* Flask Session Verify operation
*/
class FlaskSessionVerify extends Operation {
/**
* FlaskSessionVerify constructor
*/
constructor() {
super();
this.name = "Flask Session Verify";
this.module = "Crypto";
this.description = "Verifies the HMAC signature of a Flask session cookie (itsdangerous) generated.";
this.inputType = "string";
this.outputType = "JSON";
this.args = [
{
name: "Key",
type: "toggleString",
value: "",
toggleValues: ["Hex", "Decimal", "Binary", "Base64", "UTF8", "Latin1"]
},
{
name: "Salt",
type: "toggleString",
value: "cookie-session",
toggleValues: ["UTF8", "Hex", "Decimal", "Binary", "Base64", "Latin1"]
},
{
name: "Algorithm",
type: "option",
value: ["sha1", "sha256"],
},
{
name: "View TimeStamp",
type: "boolean",
value: true
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
if (!args[0].string) {
throw new OperationError("Secret key required");
}
const key = Utils.convertToByteString(args[0].string, args[0].option);
const salt = Utils.convertToByteString(args[1].string || "cookie-session", args[1].option);
const algorithm = args[2] || "sha1";
input = input.trim();
const parts = input.split(".");
if (parts.length !== 3) {
throw new OperationError("Invalid Flask token format. Expected payload.timestamp.signature");
}
const data = Utils.convertToByteString(parts[0] + "." + parts[1], "utf8");
const derivedKey = CryptoApi.getHmac(key, CryptoApi.getHasher(algorithm));
derivedKey.update(salt);
const sign = CryptoApi.getHmac(derivedKey.finalize(), CryptoApi.getHasher(algorithm));
sign.update(data);
const payloadB64 = parts[0];
const base64 = payloadB64.replace(/-/g, "+").replace(/_/g, "/");
const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
const time = parts[1];
const timeB64 = time.replace(/-/g, "+").replace(/_/g, "/");
const binary = fromBase64(timeB64);
const bytes = new Uint8Array(4);
for (let i = 0; i < 4; i++) {
bytes[i] = binary.charCodeAt(i);
}
const view = new DataView(bytes.buffer);
const timestamp = view.getInt32(0, false);
let payloadJson;
try {
payloadJson = fromBase64(padded);
} catch (e) {
throw new OperationError("Invalid Base64 payload");
}
const signB64 = toBase64(sign.finalize());
const sign64 = signB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
if (sign64 !== parts[2]) {
throw new OperationError("Invalid signature!");
}
try {
const decoded = JSON.parse(payloadJson);
if (!args[3]) {
return {
valid: true,
payload: decoded,
};
} else {
return {
valid: true,
payload: decoded,
timestamp: timestamp
};
}
} catch (e) {
throw new OperationError("Unable to decode JSON payload: " + e.message);
}
}
}
export default FlaskSessionVerify;

24
src/core/operations/FlipImage.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Flip Image operation * Flip Image operation
*/ */
class FlipImage extends Operation { class FlipImage extends Operation {
/** /**
* FlipImage constructor * FlipImage constructor
*/ */
@ -33,8 +32,8 @@ class FlipImage extends Operation {
{ {
name: "Axis", name: "Axis",
type: "option", type: "option",
value: ["Horizontal", "Vertical"] value: ["Horizontal", "Vertical"],
} },
]; ];
} }
@ -60,18 +59,24 @@ class FlipImage extends Operation {
self.sendStatusMessage("Flipping image..."); self.sendStatusMessage("Flipping image...");
switch (flipAxis) { switch (flipAxis) {
case "Horizontal": case "Horizontal":
image.flip(true, false); image.flip({
horizontal: true,
vertical: false,
});
break; break;
case "Vertical": case "Vertical":
image.flip(false, true); image.flip({
horizontal: false,
vertical: true,
});
break; break;
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -95,7 +100,6 @@ class FlipImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default FlipImage; export default FlipImage;

12
src/core/operations/FromBase32.mjs
View File

@ -6,6 +6,8 @@
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
import Utils from "../Utils.mjs"; import Utils from "../Utils.mjs";
import {ALPHABET_OPTIONS} from "../lib/Base32.mjs";
/** /**
* From Base32 operation * From Base32 operation
@ -27,8 +29,8 @@ class FromBase32 extends Operation {
this.args = [ this.args = [
{ {
name: "Alphabet", name: "Alphabet",
type: "binaryString", type: "editableOption",
value: "A-Z2-7=" value: ALPHABET_OPTIONS
}, },
{ {
name: "Remove non-alphabet chars", name: "Remove non-alphabet chars",
@ -41,6 +43,11 @@ class FromBase32 extends Operation {
pattern: "^(?:[A-Z2-7]{8})+(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})?$", pattern: "^(?:[A-Z2-7]{8})+(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})?$",
flags: "", flags: "",
args: ["A-Z2-7=", false] args: ["A-Z2-7=", false]
},
{
pattern: "^(?:[0-9A-V]{8})+(?:[0-9A-V]{2}={6}|[0-9A-V]{4}={4}|[0-9A-V]{5}={3}|[0-9A-V]{7}={1})?$",
flags: "",
args: ["0-9A-V=", false]
} }
]; ];
} }
@ -96,3 +103,4 @@ class FromBase32 extends Operation {
} }
export default FromBase32; export default FromBase32;

149
src/core/operations/FromBech32.mjs Normal file
View File

@ -0,0 +1,149 @@
/**
* @author Medjedtxm
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import { decode } from "../lib/Bech32.mjs";
import { toHex } from "../lib/Hex.mjs";
/**
* From Bech32 operation
*/
class FromBech32 extends Operation {
/**
* FromBech32 constructor
*/
constructor() {
super();
this.name = "From Bech32";
this.module = "Default";
this.description = "Bech32 is an encoding scheme primarily used for Bitcoin SegWit addresses (BIP-0173). It uses a 32-character alphabet that excludes easily confused characters (1, b, i, o) and includes a checksum for error detection.<br><br>Bech32m (BIP-0350) is an updated version used for Bitcoin Taproot addresses.<br><br>Auto-detect will attempt Bech32 first, then Bech32m if the checksum fails.<br><br>Output format options allow you to see the Human-Readable Part (HRP) along with the decoded data.";
this.infoURL = "https://wikipedia.org/wiki/Bech32";
this.inputType = "string";
this.outputType = "string";
this.args = [
{
"name": "Encoding",
"type": "option",
"value": ["Auto-detect", "Bech32", "Bech32m"]
},
{
"name": "Output Format",
"type": "option",
"value": ["Raw", "Hex", "Bitcoin scriptPubKey", "HRP: Hex", "JSON"]
}
];
this.checks = [
{
// Bitcoin mainnet SegWit/Taproot addresses
pattern: "^bc1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$",
flags: "i",
args: ["Auto-detect", "Hex"]
},
{
// Bitcoin testnet addresses
pattern: "^tb1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$",
flags: "i",
args: ["Auto-detect", "Hex"]
},
{
// AGE public keys
pattern: "^age1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$",
flags: "i",
args: ["Auto-detect", "HRP: Hex"]
},
{
// AGE secret keys
pattern: "^AGE-SECRET-KEY-1[QPZRY9X8GF2TVDW0S3JN54KHCE6MUA7L]{6,87}$",
flags: "",
args: ["Auto-detect", "HRP: Hex"]
},
{
// Litecoin mainnet addresses
pattern: "^ltc1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,87}$",
flags: "i",
args: ["Auto-detect", "Hex"]
},
{
// Generic bech32 pattern
pattern: "^[a-z]{1,83}1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]{6,}$",
flags: "i",
args: ["Auto-detect", "Hex"]
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const encoding = args[0];
const outputFormat = args[1];
input = input.trim();
if (input.length === 0) {
return "";
}
const decoded = decode(input, encoding);
// Format output based on selected option
switch (outputFormat) {
case "Raw":
return decoded.data.map(b => String.fromCharCode(b)).join("");
case "Hex":
return toHex(decoded.data, "");
case "Bitcoin scriptPubKey": {
// Convert to Bitcoin scriptPubKey format as shown in BIP-0173/BIP-0350
// Format: [OP_version][length][witness_program]
// OP_0 = 0x00, OP_1-OP_16 = 0x51-0x60
if (decoded.witnessVersion === null || decoded.data.length < 2) {
// Not a SegWit address, fall back to hex
return toHex(decoded.data, "");
}
const witnessVersion = decoded.data[0];
const witnessProgram = decoded.data.slice(1);
// Convert witness version to OP code
let opCode;
if (witnessVersion === 0) {
opCode = 0x00; // OP_0
} else if (witnessVersion >= 1 && witnessVersion <= 16) {
opCode = 0x50 + witnessVersion; // OP_1 = 0x51, ..., OP_16 = 0x60
} else {
// Invalid witness version, fall back to hex
return toHex(decoded.data, "");
}
// Build scriptPubKey: [OP_version][length][program]
const scriptPubKey = [opCode, witnessProgram.length, ...witnessProgram];
return toHex(scriptPubKey, "");
}
case "HRP: Hex":
return `${decoded.hrp}: ${toHex(decoded.data, "")}`;
case "JSON":
return JSON.stringify({
hrp: decoded.hrp,
encoding: decoded.encoding,
data: toHex(decoded.data, "")
}, null, 2);
default:
return toHex(decoded.data, "");
}
}
}
export default FromBech32;

2
src/core/operations/FromHexdump.mjs
View File

@ -43,7 +43,7 @@ class FromHexdump extends Operation {
*/ */
run(input, args) { run(input, args) {
const output = [], const output = [],
regex = /^\s*(?:[\dA-F]{4,16}h?:?)?[ \t]+((?:[\dA-F]{2} ){1,8}(?:[ \t]|[\dA-F]{2}-)(?:[\dA-F]{2} ){1,8}|(?:[\dA-F]{4} )*[\dA-F]{4}|(?:[\dA-F]{2} )*[\dA-F]{2})/igm; regex = /^\s*(?:[\dA-F]{4,16}h?:?)?[ \t]+((?:[\dA-F]{2} ){1,8}(?:[ \t]|[\dA-F]{2}-)(?:[\dA-F]{2} ){1,8}|(?:[\dA-F]{4} )+(?:[\dA-F]{2})?|(?:[\dA-F]{2} )*[\dA-F]{2})/igm;
let block, line; let block, line;
while ((block = regex.exec(input))) { while ((block = regex.exec(input))) {

84
src/core/operations/FromModhex.mjs Normal file
View File

@ -0,0 +1,84 @@
/**
* @author linuxgemini [ilteris@asenkron.com.tr]
* @copyright Crown Copyright 2024
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import { FROM_MODHEX_DELIM_OPTIONS, fromModhex } from "../lib/Modhex.mjs";
/**
* From Modhex operation
*/
class FromModhex extends Operation {
/**
* FromModhex constructor
*/
constructor() {
super();
this.name = "From Modhex";
this.module = "Default";
this.description = "Converts a modhex byte string back into its raw value.";
this.infoURL = "https://en.wikipedia.org/wiki/YubiKey#ModHex";
this.inputType = "string";
this.outputType = "byteArray";
this.args = [
{
name: "Delimiter",
type: "option",
value: FROM_MODHEX_DELIM_OPTIONS
}
];
this.checks = [
{
pattern: "^(?:[cbdefghijklnrtuv]{2})+$",
flags: "i",
args: ["None"]
},
{
pattern: "^[cbdefghijklnrtuv]{2}(?: [cbdefghijklnrtuv]{2})*$",
flags: "i",
args: ["Space"]
},
{
pattern: "^[cbdefghijklnrtuv]{2}(?:,[cbdefghijklnrtuv]{2})*$",
flags: "i",
args: ["Comma"]
},
{
pattern: "^[cbdefghijklnrtuv]{2}(?:;[cbdefghijklnrtuv]{2})*$",
flags: "i",
args: ["Semi-colon"]
},
{
pattern: "^[cbdefghijklnrtuv]{2}(?::[cbdefghijklnrtuv]{2})*$",
flags: "i",
args: ["Colon"]
},
{
pattern: "^[cbdefghijklnrtuv]{2}(?:\\n[cbdefghijklnrtuv]{2})*$",
flags: "i",
args: ["Line feed"]
},
{
pattern: "^[cbdefghijklnrtuv]{2}(?:\\r\\n[cbdefghijklnrtuv]{2})*$",
flags: "i",
args: ["CRLF"]
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {byteArray}
*/
run(input, args) {
const delim = args[0] || "Auto";
return fromModhex(input, delim, 2);
}
}
export default FromModhex;

2
src/core/operations/FromQuotedPrintable.mjs
View File

@ -23,7 +23,7 @@ class FromQuotedPrintable extends Operation {
this.name = "From Quoted Printable"; this.name = "From Quoted Printable";
this.module = "Default"; this.module = "Default";
this.description = "Converts QP-encoded text back to standard text.<br><br>e.g. The quoted-printable encoded string <code>hello=20world</code> becomes <code>hello world</code>"; this.description = "Converts QP-encoded text back to standard text. This format is a content transfer encoding common in email messages.<br><br>e.g. The quoted-printable encoded string <code>hello=20world</code> becomes <code>hello world</code>";
this.infoURL = "https://wikipedia.org/wiki/Quoted-printable"; this.infoURL = "https://wikipedia.org/wiki/Quoted-printable";
this.inputType = "string"; this.inputType = "string";
this.outputType = "byteArray"; this.outputType = "byteArray";

254
src/core/operations/GenerateAllChecksums.mjs Normal file
View File

@ -0,0 +1,254 @@
/**
* @author r4mos [2k95ljkhg@mozmail.com]
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import Adler32Checksum from "./Adler32Checksum.mjs";
import CRCChecksum from "./CRCChecksum.mjs";
import Fletcher8Checksum from "./Fletcher8Checksum.mjs";
import Fletcher16Checksum from "./Fletcher16Checksum.mjs";
import Fletcher32Checksum from "./Fletcher32Checksum.mjs";
import Fletcher64Checksum from "./Fletcher64Checksum.mjs";
/**
* Generate all checksums operation
*/
class GenerateAllChecksums extends Operation {
/**
* GenerateAllChecksums constructor
*/
constructor() {
super();
this.name = "Generate all checksums";
this.module = "Crypto";
this.description = "Generates all available checksums for the input.";
this.infoURL = "https://wikipedia.org/wiki/Checksum";
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [
{
name: "Length (bits)",
type: "option",
value: [
"All", "3", "4", "5", "6", "7", "8", "10", "11", "12", "13", "14", "15", "16", "17", "21", "24", "30", "31", "32", "40", "64", "82"
]
},
{
name: "Include names",
type: "boolean",
value: true
},
];
const adler32 = new Adler32Checksum;
const crc = new CRCChecksum;
const fletcher8 = new Fletcher8Checksum;
const fletcher16 = new Fletcher16Checksum;
const fletcher32 = new Fletcher32Checksum;
const fletcher64 = new Fletcher64Checksum;
this.checksums = [
{name: "CRC-3/GSM", algo: crc, params: ["CRC-3/GSM"]},
{name: "CRC-3/ROHC", algo: crc, params: ["CRC-3/ROHC"]},
{name: "CRC-4/G-704", algo: crc, params: ["CRC-4/G-704"]},
{name: "CRC-4/INTERLAKEN", algo: crc, params: ["CRC-4/INTERLAKEN"]},
{name: "CRC-4/ITU", algo: crc, params: ["CRC-4/ITU"]},
{name: "CRC-5/EPC", algo: crc, params: ["CRC-5/EPC"]},
{name: "CRC-5/EPC-C1G2", algo: crc, params: ["CRC-5/EPC-C1G2"]},
{name: "CRC-5/G-704", algo: crc, params: ["CRC-5/G-704"]},
{name: "CRC-5/ITU", algo: crc, params: ["CRC-5/ITU"]},
{name: "CRC-5/USB", algo: crc, params: ["CRC-5/USB"]},
{name: "CRC-6/CDMA2000-A", algo: crc, params: ["CRC-6/CDMA2000-A"]},
{name: "CRC-6/CDMA2000-B", algo: crc, params: ["CRC-6/CDMA2000-B"]},
{name: "CRC-6/DARC", algo: crc, params: ["CRC-6/DARC"]},
{name: "CRC-6/G-704", algo: crc, params: ["CRC-6/G-704"]},
{name: "CRC-6/GSM", algo: crc, params: ["CRC-6/GSM"]},
{name: "CRC-6/ITU", algo: crc, params: ["CRC-6/ITU"]},
{name: "CRC-7/MMC", algo: crc, params: ["CRC-7/MMC"]},
{name: "CRC-7/ROHC", algo: crc, params: ["CRC-7/ROHC"]},
{name: "CRC-7/UMTS", algo: crc, params: ["CRC-7/UMTS"]},
{name: "CRC-8", algo: crc, params: ["CRC-8"]},
{name: "CRC-8/8H2F", algo: crc, params: ["CRC-8/8H2F"]},
{name: "CRC-8/AES", algo: crc, params: ["CRC-8/AES"]},
{name: "CRC-8/AUTOSAR", algo: crc, params: ["CRC-8/AUTOSAR"]},
{name: "CRC-8/BLUETOOTH", algo: crc, params: ["CRC-8/BLUETOOTH"]},
{name: "CRC-8/CDMA2000", algo: crc, params: ["CRC-8/CDMA2000"]},
{name: "CRC-8/DARC", algo: crc, params: ["CRC-8/DARC"]},
{name: "CRC-8/DVB-S2", algo: crc, params: ["CRC-8/DVB-S2"]},
{name: "CRC-8/EBU", algo: crc, params: ["CRC-8/EBU"]},
{name: "CRC-8/GSM-A", algo: crc, params: ["CRC-8/GSM-A"]},
{name: "CRC-8/GSM-B", algo: crc, params: ["CRC-8/GSM-B"]},
{name: "CRC-8/HITAG", algo: crc, params: ["CRC-8/HITAG"]},
{name: "CRC-8/I-432-1", algo: crc, params: ["CRC-8/I-432-1"]},
{name: "CRC-8/I-CODE", algo: crc, params: ["CRC-8/I-CODE"]},
{name: "CRC-8/ITU", algo: crc, params: ["CRC-8/ITU"]},
{name: "CRC-8/LTE", algo: crc, params: ["CRC-8/LTE"]},
{name: "CRC-8/MAXIM", algo: crc, params: ["CRC-8/MAXIM"]},
{name: "CRC-8/MAXIM-DOW", algo: crc, params: ["CRC-8/MAXIM-DOW"]},
{name: "CRC-8/MIFARE-MAD", algo: crc, params: ["CRC-8/MIFARE-MAD"]},
{name: "CRC-8/NRSC-5", algo: crc, params: ["CRC-8/NRSC-5"]},
{name: "CRC-8/OPENSAFETY", algo: crc, params: ["CRC-8/OPENSAFETY"]},
{name: "CRC-8/ROHC", algo: crc, params: ["CRC-8/ROHC"]},
{name: "CRC-8/SAE-J1850", algo: crc, params: ["CRC-8/SAE-J1850"]},
{name: "CRC-8/SAE-J1850-ZERO", algo: crc, params: ["CRC-8/SAE-J1850-ZERO"]},
{name: "CRC-8/SMBUS", algo: crc, params: ["CRC-8/SMBUS"]},
{name: "CRC-8/TECH-3250", algo: crc, params: ["CRC-8/TECH-3250"]},
{name: "CRC-8/WCDMA", algo: crc, params: ["CRC-8/WCDMA"]},
{name: "Fletcher-8", algo: fletcher8, params: []},
{name: "CRC-10/ATM", algo: crc, params: ["CRC-10/ATM"]},
{name: "CRC-10/CDMA2000", algo: crc, params: ["CRC-10/CDMA2000"]},
{name: "CRC-10/GSM", algo: crc, params: ["CRC-10/GSM"]},
{name: "CRC-10/I-610", algo: crc, params: ["CRC-10/I-610"]},
{name: "CRC-11/FLEXRAY", algo: crc, params: ["CRC-11/FLEXRAY"]},
{name: "CRC-11/UMTS", algo: crc, params: ["CRC-11/UMTS"]},
{name: "CRC-12/3GPP", algo: crc, params: ["CRC-12/3GPP"]},
{name: "CRC-12/CDMA2000", algo: crc, params: ["CRC-12/CDMA2000"]},
{name: "CRC-12/DECT", algo: crc, params: ["CRC-12/DECT"]},
{name: "CRC-12/GSM", algo: crc, params: ["CRC-12/GSM"]},
{name: "CRC-12/UMTS", algo: crc, params: ["CRC-12/UMTS"]},
{name: "CRC-13/BBC", algo: crc, params: ["CRC-13/BBC"]},
{name: "CRC-14/DARC", algo: crc, params: ["CRC-14/DARC"]},
{name: "CRC-14/GSM", algo: crc, params: ["CRC-14/GSM"]},
{name: "CRC-15/CAN", algo: crc, params: ["CRC-15/CAN"]},
{name: "CRC-15/MPT1327", algo: crc, params: ["CRC-15/MPT1327"]},
{name: "CRC-16", algo: crc, params: ["CRC-16"]},
{name: "CRC-16/A", algo: crc, params: ["CRC-16/A"]},
{name: "CRC-16/ACORN", algo: crc, params: ["CRC-16/ACORN"]},
{name: "CRC-16/ARC", algo: crc, params: ["CRC-16/ARC"]},
{name: "CRC-16/AUG-CCITT", algo: crc, params: ["CRC-16/AUG-CCITT"]},
{name: "CRC-16/AUTOSAR", algo: crc, params: ["CRC-16/AUTOSAR"]},
{name: "CRC-16/B", algo: crc, params: ["CRC-16/B"]},
{name: "CRC-16/BLUETOOTH", algo: crc, params: ["CRC-16/BLUETOOTH"]},
{name: "CRC-16/BUYPASS", algo: crc, params: ["CRC-16/BUYPASS"]},
{name: "CRC-16/CCITT", algo: crc, params: ["CRC-16/CCITT"]},
{name: "CRC-16/CCITT-FALSE", algo: crc, params: ["CRC-16/CCITT-FALSE"]},
{name: "CRC-16/CCITT-TRUE", algo: crc, params: ["CRC-16/CCITT-TRUE"]},
{name: "CRC-16/CCITT-ZERO", algo: crc, params: ["CRC-16/CCITT-ZERO"]},
{name: "CRC-16/CDMA2000", algo: crc, params: ["CRC-16/CDMA2000"]},
{name: "CRC-16/CMS", algo: crc, params: ["CRC-16/CMS"]},
{name: "CRC-16/DARC", algo: crc, params: ["CRC-16/DARC"]},
{name: "CRC-16/DDS-110", algo: crc, params: ["CRC-16/DDS-110"]},
{name: "CRC-16/DECT-R", algo: crc, params: ["CRC-16/DECT-R"]},
{name: "CRC-16/DECT-X", algo: crc, params: ["CRC-16/DECT-X"]},
{name: "CRC-16/DNP", algo: crc, params: ["CRC-16/DNP"]},
{name: "CRC-16/EN-13757", algo: crc, params: ["CRC-16/EN-13757"]},
{name: "CRC-16/EPC", algo: crc, params: ["CRC-16/EPC"]},
{name: "CRC-16/EPC-C1G2", algo: crc, params: ["CRC-16/EPC-C1G2"]},
{name: "CRC-16/GENIBUS", algo: crc, params: ["CRC-16/GENIBUS"]},
{name: "CRC-16/GSM", algo: crc, params: ["CRC-16/GSM"]},
{name: "CRC-16/I-CODE", algo: crc, params: ["CRC-16/I-CODE"]},
{name: "CRC-16/IBM", algo: crc, params: ["CRC-16/IBM"]},
{name: "CRC-16/IBM-3740", algo: crc, params: ["CRC-16/IBM-3740"]},
{name: "CRC-16/IBM-SDLC", algo: crc, params: ["CRC-16/IBM-SDLC"]},
{name: "CRC-16/IEC-61158-2", algo: crc, params: ["CRC-16/IEC-61158-2"]},
{name: "CRC-16/ISO-HDLC", algo: crc, params: ["CRC-16/ISO-HDLC"]},
{name: "CRC-16/ISO-IEC-14443-3-A", algo: crc, params: ["CRC-16/ISO-IEC-14443-3-A"]},
{name: "CRC-16/ISO-IEC-14443-3-B", algo: crc, params: ["CRC-16/ISO-IEC-14443-3-B"]},
{name: "CRC-16/KERMIT", algo: crc, params: ["CRC-16/KERMIT"]},
{name: "CRC-16/LHA", algo: crc, params: ["CRC-16/LHA"]},
{name: "CRC-16/LJ1200", algo: crc, params: ["CRC-16/LJ1200"]},
{name: "CRC-16/LTE", algo: crc, params: ["CRC-16/LTE"]},
{name: "CRC-16/M17", algo: crc, params: ["CRC-16/M17"]},
{name: "CRC-16/MAXIM", algo: crc, params: ["CRC-16/MAXIM"]},
{name: "CRC-16/MAXIM-DOW", algo: crc, params: ["CRC-16/MAXIM-DOW"]},
{name: "CRC-16/MCRF4XX", algo: crc, params: ["CRC-16/MCRF4XX"]},
{name: "CRC-16/MODBUS", algo: crc, params: ["CRC-16/MODBUS"]},
{name: "CRC-16/NRSC-5", algo: crc, params: ["CRC-16/NRSC-5"]},
{name: "CRC-16/OPENSAFETY-A", algo: crc, params: ["CRC-16/OPENSAFETY-A"]},
{name: "CRC-16/OPENSAFETY-B", algo: crc, params: ["CRC-16/OPENSAFETY-B"]},
{name: "CRC-16/PROFIBUS", algo: crc, params: ["CRC-16/PROFIBUS"]},
{name: "CRC-16/RIELLO", algo: crc, params: ["CRC-16/RIELLO"]},
{name: "CRC-16/SPI-FUJITSU", algo: crc, params: ["CRC-16/SPI-FUJITSU"]},
{name: "CRC-16/T10-DIF", algo: crc, params: ["CRC-16/T10-DIF"]},
{name: "CRC-16/TELEDISK", algo: crc, params: ["CRC-16/TELEDISK"]},
{name: "CRC-16/TMS37157", algo: crc, params: ["CRC-16/TMS37157"]},
{name: "CRC-16/UMTS", algo: crc, params: ["CRC-16/UMTS"]},
{name: "CRC-16/USB", algo: crc, params: ["CRC-16/USB"]},
{name: "CRC-16/V-41-LSB", algo: crc, params: ["CRC-16/V-41-LSB"]},
{name: "CRC-16/V-41-MSB", algo: crc, params: ["CRC-16/V-41-MSB"]},
{name: "CRC-16/VERIFONE", algo: crc, params: ["CRC-16/VERIFONE"]},
{name: "CRC-16/X-25", algo: crc, params: ["CRC-16/X-25"]},
{name: "CRC-16/XMODEM", algo: crc, params: ["CRC-16/XMODEM"]},
{name: "CRC-16/ZMODEM", algo: crc, params: ["CRC-16/ZMODEM"]},
{name: "Fletcher-16", algo: fletcher16, params: []},
{name: "CRC-17/CAN-FD", algo: crc, params: ["CRC-17/CAN-FD"]},
{name: "CRC-21/CAN-FD", algo: crc, params: ["CRC-21/CAN-FD"]},
{name: "CRC-24/BLE", algo: crc, params: ["CRC-24/BLE"]},
{name: "CRC-24/FLEXRAY-A", algo: crc, params: ["CRC-24/FLEXRAY-A"]},
{name: "CRC-24/FLEXRAY-B", algo: crc, params: ["CRC-24/FLEXRAY-B"]},
{name: "CRC-24/INTERLAKEN", algo: crc, params: ["CRC-24/INTERLAKEN"]},
{name: "CRC-24/LTE-A", algo: crc, params: ["CRC-24/LTE-A"]},
{name: "CRC-24/LTE-B", algo: crc, params: ["CRC-24/LTE-B"]},
{name: "CRC-24/OPENPGP", algo: crc, params: ["CRC-24/OPENPGP"]},
{name: "CRC-24/OS-9", algo: crc, params: ["CRC-24/OS-9"]},
{name: "CRC-30/CDMA", algo: crc, params: ["CRC-30/CDMA"]},
{name: "CRC-31/PHILIPS", algo: crc, params: ["CRC-31/PHILIPS"]},
{name: "Adler-32", algo: adler32, params: []},
{name: "CRC-32", algo: crc, params: ["CRC-32"]},
{name: "CRC-32/AAL5", algo: crc, params: ["CRC-32/AAL5"]},
{name: "CRC-32/ADCCP", algo: crc, params: ["CRC-32/ADCCP"]},
{name: "CRC-32/AIXM", algo: crc, params: ["CRC-32/AIXM"]},
{name: "CRC-32/AUTOSAR", algo: crc, params: ["CRC-32/AUTOSAR"]},
{name: "CRC-32/BASE91-C", algo: crc, params: ["CRC-32/BASE91-C"]},
{name: "CRC-32/BASE91-D", algo: crc, params: ["CRC-32/BASE91-D"]},
{name: "CRC-32/BZIP2", algo: crc, params: ["CRC-32/BZIP2"]},
{name: "CRC-32/C", algo: crc, params: ["CRC-32/C"]},
{name: "CRC-32/CASTAGNOLI", algo: crc, params: ["CRC-32/CASTAGNOLI"]},
{name: "CRC-32/CD-ROM-EDC", algo: crc, params: ["CRC-32/CD-ROM-EDC"]},
{name: "CRC-32/CKSUM", algo: crc, params: ["CRC-32/CKSUM"]},
{name: "CRC-32/D", algo: crc, params: ["CRC-32/D"]},
{name: "CRC-32/DECT-B", algo: crc, params: ["CRC-32/DECT-B"]},
{name: "CRC-32/INTERLAKEN", algo: crc, params: ["CRC-32/INTERLAKEN"]},
{name: "CRC-32/ISCSI", algo: crc, params: ["CRC-32/ISCSI"]},
{name: "CRC-32/ISO-HDLC", algo: crc, params: ["CRC-32/ISO-HDLC"]},
{name: "CRC-32/JAMCRC", algo: crc, params: ["CRC-32/JAMCRC"]},
{name: "CRC-32/MEF", algo: crc, params: ["CRC-32/MEF"]},
{name: "CRC-32/MPEG-2", algo: crc, params: ["CRC-32/MPEG-2"]},
{name: "CRC-32/NVME", algo: crc, params: ["CRC-32/NVME"]},
{name: "CRC-32/PKZIP", algo: crc, params: ["CRC-32/PKZIP"]},
{name: "CRC-32/POSIX", algo: crc, params: ["CRC-32/POSIX"]},
{name: "CRC-32/Q", algo: crc, params: ["CRC-32/Q"]},
{name: "CRC-32/SATA", algo: crc, params: ["CRC-32/SATA"]},
{name: "CRC-32/V-42", algo: crc, params: ["CRC-32/V-42"]},
{name: "CRC-32/XFER", algo: crc, params: ["CRC-32/XFER"]},
{name: "CRC-32/XZ", algo: crc, params: ["CRC-32/XZ"]},
{name: "Fletcher-32", algo: fletcher32, params: []},
{name: "CRC-40/GSM", algo: crc, params: ["CRC-40/GSM"]},
{name: "CRC-64/ECMA-182", algo: crc, params: ["CRC-64/ECMA-182"]},
{name: "CRC-64/GO-ECMA", algo: crc, params: ["CRC-64/GO-ECMA"]},
{name: "CRC-64/GO-ISO", algo: crc, params: ["CRC-64/GO-ISO"]},
{name: "CRC-64/MS", algo: crc, params: ["CRC-64/MS"]},
{name: "CRC-64/NVME", algo: crc, params: ["CRC-64/NVME"]},
{name: "CRC-64/REDIS", algo: crc, params: ["CRC-64/REDIS"]},
{name: "CRC-64/WE", algo: crc, params: ["CRC-64/WE"]},
{name: "CRC-64/XZ", algo: crc, params: ["CRC-64/XZ"]},
{name: "Fletcher-64", algo: fletcher64, params: []},
{name: "CRC-82/DARC", algo: crc, params: ["CRC-82/DARC"]}
];
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const [length, includeNames] = args;
let output = "";
this.checksums.forEach(checksum => {
const checksumLength = checksum.name.match(new RegExp("-(\\d{1,2})(\\/|$)"))[1];
if (length === "All" || length === checksumLength) {
const value = checksum.algo.run(new Uint8Array(input), checksum.params || []);
output += includeNames ?
`${checksum.name}:${" ".repeat(25-checksum.name.length)}${value}\n`:
`${value}\n`;
}
});
return output;
}
}
export default GenerateAllChecksums;

26
src/core/operations/GenerateAllHashes.mjs
View File

@ -22,14 +22,6 @@ import HAS160 from "./HAS160.mjs";
import Whirlpool from "./Whirlpool.mjs"; import Whirlpool from "./Whirlpool.mjs";
import SSDEEP from "./SSDEEP.mjs"; import SSDEEP from "./SSDEEP.mjs";
import CTPH from "./CTPH.mjs"; import CTPH from "./CTPH.mjs";
import Fletcher8Checksum from "./Fletcher8Checksum.mjs";
import Fletcher16Checksum from "./Fletcher16Checksum.mjs";
import Fletcher32Checksum from "./Fletcher32Checksum.mjs";
import Fletcher64Checksum from "./Fletcher64Checksum.mjs";
import Adler32Checksum from "./Adler32Checksum.mjs";
import CRC8Checksum from "./CRC8Checksum.mjs";
import CRC16Checksum from "./CRC16Checksum.mjs";
import CRC32Checksum from "./CRC32Checksum.mjs";
import BLAKE2b from "./BLAKE2b.mjs"; import BLAKE2b from "./BLAKE2b.mjs";
import BLAKE2s from "./BLAKE2s.mjs"; import BLAKE2s from "./BLAKE2s.mjs";
import Streebog from "./Streebog.mjs"; import Streebog from "./Streebog.mjs";
@ -114,16 +106,6 @@ class GenerateAllHashes extends Operation {
{name: "SSDEEP", algo: (new SSDEEP()), inputType: "str"}, {name: "SSDEEP", algo: (new SSDEEP()), inputType: "str"},
{name: "CTPH", algo: (new CTPH()), inputType: "str"} {name: "CTPH", algo: (new CTPH()), inputType: "str"}
]; ];
this.checksums = [
{name: "Fletcher-8", algo: (new Fletcher8Checksum), inputType: "byteArray", params: []},
{name: "Fletcher-16", algo: (new Fletcher16Checksum), inputType: "byteArray", params: []},
{name: "Fletcher-32", algo: (new Fletcher32Checksum), inputType: "byteArray", params: []},
{name: "Fletcher-64", algo: (new Fletcher64Checksum), inputType: "byteArray", params: []},
{name: "Adler-32", algo: (new Adler32Checksum), inputType: "byteArray", params: []},
{name: "CRC-8", algo: (new CRC8Checksum), inputType: "arrayBuffer", params: ["CRC-8"]},
{name: "CRC-16", algo: (new CRC16Checksum), inputType: "arrayBuffer", params: []},
{name: "CRC-32", algo: (new CRC32Checksum), inputType: "arrayBuffer", params: []}
];
} }
/** /**
@ -144,14 +126,6 @@ class GenerateAllHashes extends Operation {
output += this.formatDigest(digest, length, includeNames, hash.name); output += this.formatDigest(digest, length, includeNames, hash.name);
}); });
if (length === "All") {
output += "\nChecksums:\n";
this.checksums.forEach(checksum => {
digest = this.executeAlgo(checksum.algo, checksum.inputType, checksum.params || []);
output += this.formatDigest(digest, length, includeNames, checksum.name);
});
}
return output; return output;
} }

63
src/core/operations/GenerateImage.mjs
View File

@ -10,13 +10,12 @@ import Utils from "../Utils.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime, ResizeStrategy, rgbaToInt } from "jimp";
/** /**
* Generate Image operation * Generate Image operation
*/ */
class GenerateImage extends Operation { class GenerateImage extends Operation {
/** /**
* GenerateImage constructor * GenerateImage constructor
*/ */
@ -25,27 +24,28 @@ class GenerateImage extends Operation {
this.name = "Generate Image"; this.name = "Generate Image";
this.module = "Image"; this.module = "Image";
this.description = "Generates an image using the input as pixel values."; this.description =
"Generates an image using the input as pixel values.";
this.infoURL = ""; this.infoURL = "";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
this.presentType = "html"; this.presentType = "html";
this.args = [ this.args = [
{ {
"name": "Mode", name: "Mode",
"type": "option", type: "option",
"value": ["Greyscale", "RG", "RGB", "RGBA", "Bits"] value: ["Greyscale", "RG", "RGB", "RGBA", "Bits"],
}, },
{ {
"name": "Pixel Scale Factor", name: "Pixel Scale Factor",
"type": "number", type: "number",
"value": 8, value: 8,
}, },
{ {
"name": "Pixels per row", name: "Pixels per row",
"type": "number", type: "number",
"value": 64, value: 64,
} },
]; ];
} }
@ -67,21 +67,23 @@ class GenerateImage extends Operation {
} }
const bytePerPixelMap = { const bytePerPixelMap = {
"Greyscale": 1, Greyscale: 1,
"RG": 2, RG: 2,
"RGB": 3, RGB: 3,
"RGBA": 4, RGBA: 4,
"Bits": 1/8, Bits: 1 / 8,
}; };
const bytesPerPixel = bytePerPixelMap[mode]; const bytesPerPixel = bytePerPixelMap[mode];
if (bytesPerPixel > 0 && input.length % bytesPerPixel !== 0) { if (bytesPerPixel > 0 && input.length % bytesPerPixel !== 0) {
throw new OperationError(`Number of bytes is not a divisor of ${bytesPerPixel}`); throw new OperationError(
`Number of bytes is not a divisor of ${bytesPerPixel}`,
);
} }
const height = Math.ceil(input.length / bytesPerPixel / width); const height = Math.ceil(input.length / bytesPerPixel / width);
const image = await new Jimp(width, height, (err, image) => {}); const image = new Jimp({ width, height });
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Generating image from data..."); self.sendStatusMessage("Generating image from data...");
@ -94,8 +96,8 @@ class GenerateImage extends Operation {
const x = index % width; const x = index % width;
const y = Math.floor(index / width); const y = Math.floor(index / width);
const value = curByte[k] === "0" ? 0xFF : 0x00; const value = curByte[k] === "0" ? 0xff : 0x00;
const pixel = Jimp.rgbaToInt(value, value, value, 0xFF); const pixel = rgbaToInt(value, value, value, 0xff);
image.setPixelColor(pixel, x, y); image.setPixelColor(pixel, x, y);
} }
} }
@ -109,7 +111,7 @@ class GenerateImage extends Operation {
let red = 0x00; let red = 0x00;
let green = 0x00; let green = 0x00;
let blue = 0x00; let blue = 0x00;
let alpha = 0xFF; let alpha = 0xff;
switch (mode) { switch (mode) {
case "Greyscale": case "Greyscale":
@ -139,10 +141,12 @@ class GenerateImage extends Operation {
} }
try { try {
const pixel = Jimp.rgbaToInt(red, green, blue, alpha); const pixel = rgbaToInt(red, green, blue, alpha);
image.setPixelColor(pixel, x, y); image.setPixelColor(pixel, x, y);
} catch (err) { } catch (err) {
throw new OperationError(`Error while generating image from pixel values. (${err})`); throw new OperationError(
`Error while generating image from pixel values. (${err})`,
);
} }
} }
} }
@ -151,11 +155,15 @@ class GenerateImage extends Operation {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Scaling image..."); self.sendStatusMessage("Scaling image...");
image.scaleToFit(width*scale, height*scale, Jimp.RESIZE_NEAREST_NEIGHBOR); image.scaleToFit({
w: width * scale,
h: height * scale,
mode: ResizeStrategy.NEAREST_NEIGHBOR,
});
} }
try { try {
const imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); const imageBuffer = await image.getBuffer(JimpMime.png);
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error generating image. (${err})`); throw new OperationError(`Error generating image. (${err})`);
@ -178,7 +186,6 @@ class GenerateImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default GenerateImage; export default GenerateImage;

56
src/core/operations/GenerateUUID.mjs
View File

@ -5,8 +5,8 @@
*/ */
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
import crypto from "crypto"; import * as uuid from "uuid";
import OperationError from "../errors/OperationError.mjs";
/** /**
* Generate UUID operation * Generate UUID operation
*/ */
@ -20,11 +20,38 @@ class GenerateUUID extends Operation {
this.name = "Generate UUID"; this.name = "Generate UUID";
this.module = "Crypto"; this.module = "Crypto";
this.description = "Generates an RFC 4122 version 4 compliant Universally Unique Identifier (UUID), also known as a Globally Unique Identifier (GUID).<br><br>A version 4 UUID relies on random numbers, in this case generated using <code>window.crypto</code> if available and falling back to <code>Math.random</code> if not."; this.description =
"Generates an RFC 9562 (formerly RFC 4122) compliant Universally Unique Identifier (UUID), " +
"also known as a Globally Unique Identifier (GUID).<br>" +
"<br>" +
"We currently support generating the following UUID versions:<br>" +
"<ul>" +
"<li><strong>v1</strong>: Timestamp-based</li>" +
"<li><strong>v3</strong>: Namespace w/ MD5</li>" +
"<li><strong>v4</strong>: Random (default)</li>" +
"<li><strong>v5</strong>: Namespace w/ SHA-1</li>" +
"<li><strong>v6</strong>: Timestamp, reordered</li>" +
"<li><strong>v7</strong>: Unix Epoch time-based</li>" +
"</ul>" +
"UUIDs are generated using the <a href='https://npmjs.org/uuid/'><code>uuid</code><a> package.<br>";
this.infoURL = "https://wikipedia.org/wiki/Universally_unique_identifier"; this.infoURL = "https://wikipedia.org/wiki/Universally_unique_identifier";
this.inputType = "string"; this.inputType = "string";
this.outputType = "string"; this.outputType = "string";
this.args = []; this.args = [
{
name: "Version",
hint: "UUID version",
type: "option",
value: ["v1", "v3", "v4", "v5", "v6", "v7"],
defaultIndex: 2,
},
{
name: "Namespace",
hint: "UUID namespace (UUID; valid for v3 and v5)",
type: "string",
value: "1b671a64-40d5-491e-99b0-da01ff1f3341"
}
];
} }
/** /**
@ -33,16 +60,17 @@ class GenerateUUID extends Operation {
* @returns {string} * @returns {string}
*/ */
run(input, args) { run(input, args) {
const buf = new Uint32Array(4).map(() => { const [version, namespace] = args;
return crypto.randomBytes(4).readUInt32BE(0, true); const hasDesiredVersion = typeof uuid[version] === "function";
}); if (!hasDesiredVersion) throw new OperationError("Invalid UUID version");
let i = 0;
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) { const requiresNamespace = ["v3", "v5"].includes(version);
const r = (buf[i >> 3] >> ((i % 8) * 4)) & 0xf, if (!requiresNamespace) return uuid[version]();
v = c === "x" ? r : (r & 0x3 | 0x8);
i++; const hasValidNamespace = typeof namespace === "string" && uuid.validate(namespace);
return v.toString(16); if (!hasValidNamespace) throw new OperationError("Invalid UUID namespace");
});
return uuid[version](input, namespace);
} }
} }

20
src/core/operations/ImageBrightnessContrast.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Image Brightness / Contrast operation * Image Brightness / Contrast operation
*/ */
class ImageBrightnessContrast extends Operation { class ImageBrightnessContrast extends Operation {
/** /**
* ImageBrightnessContrast constructor * ImageBrightnessContrast constructor
*/ */
@ -35,15 +34,15 @@ class ImageBrightnessContrast extends Operation {
type: "number", type: "number",
value: 0, value: 0,
min: -100, min: -100,
max: 100 max: 100,
}, },
{ {
name: "Contrast", name: "Contrast",
type: "number", type: "number",
value: 0, value: 0,
min: -100, min: -100,
max: 100 max: 100,
} },
]; ];
} }
@ -77,14 +76,16 @@ class ImageBrightnessContrast extends Operation {
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error adjusting image brightness or contrast. (${err})`); throw new OperationError(
`Error adjusting image brightness or contrast. (${err})`,
);
} }
} }
@ -104,7 +105,6 @@ class ImageBrightnessContrast extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default ImageBrightnessContrast; export default ImageBrightnessContrast;

27
src/core/operations/ImageFilter.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Image Filter operation * Image Filter operation
*/ */
class ImageFilter extends Operation { class ImageFilter extends Operation {
/** /**
* ImageFilter constructor * ImageFilter constructor
*/ */
@ -33,11 +32,8 @@ class ImageFilter extends Operation {
{ {
name: "Filter type", name: "Filter type",
type: "option", type: "option",
value: [ value: ["Greyscale", "Sepia"],
"Greyscale", },
"Sepia"
]
}
]; ];
} }
@ -60,7 +56,11 @@ class ImageFilter extends Operation {
} }
try { try {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Applying " + filterType.toLowerCase() + " filter to image..."); self.sendStatusMessage(
"Applying " +
filterType.toLowerCase() +
" filter to image...",
);
if (filterType === "Greyscale") { if (filterType === "Greyscale") {
image.greyscale(); image.greyscale();
} else { } else {
@ -68,14 +68,16 @@ class ImageFilter extends Operation {
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error applying filter to image. (${err})`); throw new OperationError(
`Error applying filter to image. (${err})`,
);
} }
} }
@ -95,7 +97,6 @@ class ImageFilter extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default ImageFilter; export default ImageFilter;

42
src/core/operations/ImageHueSaturationLightness.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Image Hue/Saturation/Lightness operation * Image Hue/Saturation/Lightness operation
*/ */
class ImageHueSaturationLightness extends Operation { class ImageHueSaturationLightness extends Operation {
/** /**
* ImageHueSaturationLightness constructor * ImageHueSaturationLightness constructor
*/ */
@ -24,7 +23,8 @@ class ImageHueSaturationLightness extends Operation {
this.name = "Image Hue/Saturation/Lightness"; this.name = "Image Hue/Saturation/Lightness";
this.module = "Image"; this.module = "Image";
this.description = "Adjusts the hue / saturation / lightness (HSL) values of an image."; this.description =
"Adjusts the hue / saturation / lightness (HSL) values of an image.";
this.infoURL = ""; this.infoURL = "";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -35,22 +35,22 @@ class ImageHueSaturationLightness extends Operation {
type: "number", type: "number",
value: 0, value: 0,
min: -360, min: -360,
max: 360 max: 360,
}, },
{ {
name: "Saturation", name: "Saturation",
type: "number", type: "number",
value: 0, value: 0,
min: -100, min: -100,
max: 100 max: 100,
}, },
{ {
name: "Lightness", name: "Lightness",
type: "number", type: "number",
value: 0, value: 0,
min: -100, min: -100,
max: 100 max: 100,
} },
]; ];
} }
@ -76,43 +76,45 @@ class ImageHueSaturationLightness extends Operation {
if (hue !== 0) { if (hue !== 0) {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Changing image hue..."); self.sendStatusMessage("Changing image hue...");
image.colour([ image.color([
{ {
apply: "hue", apply: "hue",
params: [hue] params: [hue],
} },
]); ]);
} }
if (saturation !== 0) { if (saturation !== 0) {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Changing image saturation..."); self.sendStatusMessage("Changing image saturation...");
image.colour([ image.color([
{ {
apply: "saturate", apply: "saturate",
params: [saturation] params: [saturation],
} },
]); ]);
} }
if (lightness !== 0) { if (lightness !== 0) {
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Changing image lightness..."); self.sendStatusMessage("Changing image lightness...");
image.colour([ image.color([
{ {
apply: "lighten", apply: "lighten",
params: [lightness] params: [lightness],
} },
]); ]);
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
throw new OperationError(`Error adjusting image hue / saturation / lightness. (${err})`); throw new OperationError(
`Error adjusting image hue / saturation / lightness. (${err})`,
);
} }
} }

14
src/core/operations/ImageOpacity.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Image Opacity operation * Image Opacity operation
*/ */
class ImageOpacity extends Operation { class ImageOpacity extends Operation {
/** /**
* ImageOpacity constructor * ImageOpacity constructor
*/ */
@ -35,8 +34,8 @@ class ImageOpacity extends Operation {
type: "number", type: "number",
value: 100, value: 100,
min: 0, min: 0,
max: 100 max: 100,
} },
]; ];
} }
@ -63,10 +62,10 @@ class ImageOpacity extends Operation {
image.opacity(opacity / 100); image.opacity(opacity / 100);
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -90,7 +89,6 @@ class ImageOpacity extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default ImageOpacity; export default ImageOpacity;

10
src/core/operations/InvertImage.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Invert Image operation * Invert Image operation
*/ */
class InvertImage extends Operation { class InvertImage extends Operation {
/** /**
* InvertImage constructor * InvertImage constructor
*/ */
@ -54,10 +53,10 @@ class InvertImage extends Operation {
image.invert(); image.invert();
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -81,7 +80,6 @@ class InvertImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default InvertImage; export default InvertImage;

46
src/core/operations/JSONtoYAML.mjs Normal file
View File

@ -0,0 +1,46 @@
/**
* @author ccarpo [ccarpo@gmx.net]
* @copyright Crown Copyright 2021
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import YAML from "yaml";
/**
* JSON to YAML operation
*/
class JSONtoYAML extends Operation {
/**
* JSONtoYAML constructor
*/
constructor() {
super();
this.name = "JSON to YAML";
this.module = "Default";
this.description = "Format a JSON object into YAML";
this.infoURL = "https://en.wikipedia.org/wiki/YAML";
this.inputType = "JSON";
this.outputType = "string";
this.args = [];
}
/**
* @param {JSON} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
try {
return YAML.stringify(input);
} catch (err) {
throw new OperationError("Test");
}
}
}
export default JSONtoYAML;

56
src/core/operations/Jq.mjs Normal file
View File

@ -0,0 +1,56 @@
/**
* @author zhzy0077 [zhzy0077@hotmail.com]
* @copyright Crown Copyright 2023
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import * as jq from "jq-wasm";
/**
* jq operation
*/
class Jq extends Operation {
/**
* Jq constructor
*/
constructor() {
super();
this.name = "Jq";
this.module = "Jq";
this.description = "jq is a lightweight and flexible command-line JSON processor.";
this.infoURL = "https://github.com/jqlang/jq";
this.inputType = "JSON";
this.outputType = "string";
this.args = [
{
name: "Query",
type: "string",
value: ""
}
];
}
/**
* @param {JSON} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
return (async () => {
const [query] = args;
try {
const result = await jq.json(input, query);
return JSON.stringify(result);
} catch (err) {
throw new OperationError(`Invalid jq expression: ${err.message}`);
}
})();
}
}
export default Jq;

65
src/core/operations/Jsonata.mjs Normal file
View File

@ -0,0 +1,65 @@
/**
* @author Jon K (jon@ajarsoftware.com)
* @copyright Crown Copyright 2016
* @license Apache-2.0
*/
import jsonata from "jsonata";
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
/**
* Jsonata Query operation
*/
class JsonataQuery extends Operation {
/**
* JsonataQuery constructor
*/
constructor() {
super();
this.name = "Jsonata Query";
this.module = "Code";
this.description =
"Query and transform JSON data with a jsonata query.";
this.infoURL = "https://docs.jsonata.org/overview.html";
this.inputType = "string";
this.outputType = "string";
this.args = [
{
name: "Query",
type: "text",
value: "string",
},
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
async run(input, args) {
const [query] = args;
let result, jsonObj;
try {
jsonObj = JSON.parse(input);
} catch (err) {
throw new OperationError(`Invalid input JSON: ${err.message}`);
}
try {
const expression = jsonata(query);
result = await expression.evaluate(jsonObj);
} catch (err) {
throw new OperationError(
`Invalid Jsonata Expression: ${err.message}`
);
}
return JSON.stringify(result === undefined ? "" : result);
}
}
export default JsonataQuery;

171
src/core/operations/MIMEDecoding.mjs Normal file
View File

@ -0,0 +1,171 @@
/**
* @author mshwed [m@ttshwed.com]
* @copyright Crown Copyright 2019
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import Utils from "../Utils.mjs";
import { fromHex } from "../lib/Hex.mjs";
import { fromBase64 } from "../lib/Base64.mjs";
import cptable from "codepage";
/**
* MIME Decoding operation
*/
class MIMEDecoding extends Operation {
/**
* MIMEDecoding constructor
*/
constructor() {
super();
this.name = "MIME Decoding";
this.module = "Default";
this.description = "Enables the decoding of MIME message header extensions for non-ASCII text";
this.infoURL = "https://tools.ietf.org/html/rfc2047";
this.inputType = "byteArray";
this.outputType = "string";
this.args = [];
}
/**
* @param {byteArray} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const mimeEncodedText = Utils.byteArrayToUtf8(input);
const encodedHeaders = mimeEncodedText.replace(/\r\n/g, "\n");
const decodedHeader = this.decodeHeaders(encodedHeaders);
return decodedHeader;
}
/**
* Decode MIME header strings
*
* @param headerString
*/
decodeHeaders(headerString) {
// No encoded words detected
let i = headerString.indexOf("=?");
if (i === -1) return headerString;
let decodedHeaders = headerString.slice(0, i);
let header = headerString.slice(i);
let isBetweenWords = false;
let start, cur, charset, encoding, j, end, text;
while (header.length > -1) {
start = header.indexOf("=?");
if (start === -1) break;
cur = start + "=?".length;
i = header.slice(cur).indexOf("?");
if (i === -1) break;
charset = header.slice(cur, cur + i);
cur += i + "?".length;
if (header.length < cur + "Q??=".length) break;
encoding = header[cur];
cur += 1;
if (header[cur] !== "?") break;
cur += 1;
j = header.slice(cur).indexOf("?=");
if (j === -1) break;
text = header.slice(cur, cur + j);
end = cur + j + "?=".length;
if (encoding.toLowerCase() === "b") {
text = fromBase64(text);
} else if (encoding.toLowerCase() === "q") {
text = this.parseQEncodedWord(text);
} else {
isBetweenWords = false;
decodedHeaders += header.slice(0, start + 2);
header = header.slice(start + 2);
}
if (start > 0 && (!isBetweenWords || header.slice(0, start).search(/\S/g) > -1)) {
decodedHeaders += header.slice(0, start);
}
decodedHeaders += this.convertFromCharset(charset, text);
header = header.slice(end);
isBetweenWords = true;
}
if (header.length > 0) {
decodedHeaders += header;
}
return decodedHeaders;
}
/**
* Converts decoded text for supported charsets.
* Supports UTF-8, US-ASCII, ISO-8859-*
*
* @param encodedWord
*/
convertFromCharset(charset, encodedText) {
charset = charset.toLowerCase();
const parsedCharset = charset.split("-");
if (parsedCharset.length === 2 && parsedCharset[0] === "utf" && charset === "utf-8") {
return cptable.utils.decode(65001, encodedText);
} else if (parsedCharset.length === 2 && charset === "us-ascii") {
return cptable.utils.decode(20127, encodedText);
} else if (parsedCharset.length === 3 && parsedCharset[0] === "iso" && parsedCharset[1] === "8859") {
const isoCharset = parseInt(parsedCharset[2], 10);
if (isoCharset >= 1 && isoCharset <= 16) {
return cptable.utils.decode(28590 + isoCharset, encodedText);
}
}
throw new OperationError("Unhandled Charset");
}
/**
* Parses a Q encoded word
*
* @param encodedWord
*/
parseQEncodedWord(encodedWord) {
let decodedWord = "";
for (let i = 0; i < encodedWord.length; i++) {
if (encodedWord[i] === "_") {
decodedWord += " ";
// Parse hex encoding
} else if (encodedWord[i] === "=") {
if ((i + 2) >= encodedWord.length) throw new OperationError("Incorrectly Encoded Word");
const decodedHex = Utils.byteArrayToChars(fromHex(encodedWord.substring(i + 1, i + 3)));
decodedWord += decodedHex;
i += 2;
} else if (
(encodedWord[i].charCodeAt(0) >= " ".charCodeAt(0) && encodedWord[i].charCodeAt(0) <= "~".charCodeAt(0)) ||
encodedWord[i] === "\n" ||
encodedWord[i] === "\r" ||
encodedWord[i] === "\t") {
decodedWord += encodedWord[i];
} else {
throw new OperationError("Incorrectly Encoded Word");
}
}
return decodedWord;
}
}
export default MIMEDecoding;

10
src/core/operations/NormaliseImage.mjs
View File

@ -8,13 +8,12 @@ import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs"; import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Normalise Image operation * Normalise Image operation
*/ */
class NormaliseImage extends Operation { class NormaliseImage extends Operation {
/** /**
* NormaliseImage constructor * NormaliseImage constructor
*/ */
@ -52,10 +51,10 @@ class NormaliseImage extends Operation {
image.normalize(); image.normalize();
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -79,7 +78,6 @@ class NormaliseImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default NormaliseImage; export default NormaliseImage;

126
src/core/operations/PHPSerialize.mjs Normal file
View File

@ -0,0 +1,126 @@
/**
* @author brun0ne [brunonblok@gmail.com]
* @copyright Crown Copyright 2023
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
/**
* PHP Serialize operation
*/
class PHPSerialize extends Operation {
/**
* PHPSerialize constructor
*/
constructor() {
super();
this.name = "PHP Serialize";
this.module = "Default";
this.description = "Performs PHP serialization on JSON data.<br><br>This function does not support <code>object</code> tags.<br><br>Since PHP doesn't distinguish dicts and arrays, this operation is not always symmetric to <code>PHP Deserialize</code>.<br><br>Example:<br><code>[5,&quot;abc&quot;,true]</code><br>becomes<br><code>a:3:{i:0;i:5;i:1;s:3:&quot;abc&quot;;i:2;b:1;}<code>";
this.infoURL = "https://www.phpinternalsbook.com/php5/classes_objects/serialization.html";
this.inputType = "JSON";
this.outputType = "string";
this.args = [];
}
/**
* @param {JSON} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
/**
* Determines if a number is an integer
* @param {number} value
* @returns {boolean}
*/
function isInteger(value) {
return typeof value === "number" && parseInt(value.toString(), 10) === value;
}
/**
* Serialize basic types
* @param {string | number | boolean} content
* @returns {string}
*/
function serializeBasicTypes(content) {
const basicTypes = {
"string": "s",
"integer": "i",
"float": "d",
"boolean": "b"
};
/**
* Booleans
* cast to 0 or 1
*/
if (typeof content === "boolean") {
return `${basicTypes.boolean}:${content ? 1 : 0}`;
}
/* Numbers */
if (typeof content === "number") {
if (isInteger(content)) {
return `${basicTypes.integer}:${content.toString()}`;
} else {
return `${basicTypes.float}:${content.toString()}`;
}
}
/* Strings */
if (typeof content === "string")
return `${basicTypes.string}:${content.length}:"${content}"`;
/** This should be unreachable */
throw new OperationError(`Encountered a non-implemented type: ${typeof content}`);
}
/**
* Recursively serialize
* @param {*} object
* @returns {string}
*/
function serialize(object) {
/* Null */
if (object == null) {
return `N;`;
}
if (typeof object !== "object") {
/* Basic types */
return `${serializeBasicTypes(object)};`;
} else if (object instanceof Array) {
/* Arrays */
const serializedElements = [];
for (let i = 0; i < object.length; i++) {
serializedElements.push(`${serialize(i)}${serialize(object[i])}`);
}
return `a:${object.length}:{${serializedElements.join("")}}`;
} else if (object instanceof Object) {
/**
* Objects
* Note: the output cannot be guaranteed to be in the same order as the input
*/
const serializedElements = [];
const keys = Object.keys(object);
for (const key of keys) {
serializedElements.push(`${serialize(key)}${serialize(object[key])}`);
}
return `a:${keys.length}:{${serializedElements.join("")}}`;
}
/** This should be unreachable */
throw new OperationError(`Encountered a non-implemented type: ${typeof object}`);
}
return serialize(input);
}
}
export default PHPSerialize;

26
src/core/operations/ParseQRCode.mjs
View File

@ -13,7 +13,6 @@ import { parseQrCode } from "../lib/QRCode.mjs";
* Parse QR Code operation * Parse QR Code operation
*/ */
class ParseQRCode extends Operation { class ParseQRCode extends Operation {
/** /**
* ParseQRCode constructor * ParseQRCode constructor
*/ */
@ -22,24 +21,26 @@ class ParseQRCode extends Operation {
this.name = "Parse QR Code"; this.name = "Parse QR Code";
this.module = "Image"; this.module = "Image";
this.description = "Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.<br><br><u>Normalise Image</u><br>Attempts to normalise the image before parsing it to improve detection of a QR code."; this.description =
"Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.<br><br><u>Normalise Image</u><br>Attempts to normalise the image before parsing it to improve detection of a QR code.";
this.infoURL = "https://wikipedia.org/wiki/QR_code"; this.infoURL = "https://wikipedia.org/wiki/QR_code";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "string"; this.outputType = "string";
this.args = [ this.args = [
{ {
"name": "Normalise image", name: "Normalise image",
"type": "boolean", type: "boolean",
"value": false value: false,
} },
]; ];
this.checks = [ this.checks = [
{ {
"pattern": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)", pattern:
"flags": "", "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)",
"args": [false], flags: "",
"useful": true args: [false],
} useful: true,
},
]; ];
} }
@ -54,9 +55,8 @@ class ParseQRCode extends Operation {
if (!isImage(input)) { if (!isImage(input)) {
throw new OperationError("Invalid file type."); throw new OperationError("Invalid file type.");
} }
return await parseQrCode(input, normalise); return parseQrCode(input, normalise);
} }
} }
export default ParseQRCode; export default ParseQRCode;

10
src/core/operations/ParseX509Certificate.mjs
View File

@ -6,7 +6,8 @@
import r from "jsrsasign"; import r from "jsrsasign";
import { fromBase64 } from "../lib/Base64.mjs"; import { fromBase64 } from "../lib/Base64.mjs";
import { toHex } from "../lib/Hex.mjs"; import { runHash } from "../lib/Hash.mjs";
import { fromHex, toHex } from "../lib/Hex.mjs";
import { formatByteStr, formatDnObj } from "../lib/PublicKey.mjs"; import { formatByteStr, formatDnObj } from "../lib/PublicKey.mjs";
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
import Utils from "../Utils.mjs"; import Utils from "../Utils.mjs";
@ -81,7 +82,8 @@ class ParseX509Certificate extends Operation {
} }
if (undefinedInputFormat) throw "Undefined input format"; if (undefinedInputFormat) throw "Undefined input format";
const sn = cert.getSerialNumberHex(), const hex = Utils.strToArrayBuffer(Utils.byteArrayToChars(fromHex(cert.hex))),
sn = cert.getSerialNumberHex(),
issuer = cert.getIssuer(), issuer = cert.getIssuer(),
subject = cert.getSubject(), subject = cert.getSubject(),
pk = cert.getPublicKey(), pk = cert.getPublicKey(),
@ -191,6 +193,10 @@ Issuer
${issuerStr} ${issuerStr}
Subject Subject
${subjectStr} ${subjectStr}
Fingerprints
MD5: ${runHash("md5", hex)}
SHA1: ${runHash("sha1", hex)}
SHA256: ${runHash("sha256", hex)}
Public Key Public Key
${pkStr.slice(0, -1)} ${pkStr.slice(0, -1)}
Certificate Signature Certificate Signature

164
src/core/operations/PseudoRandomIntegerGenerator.mjs Normal file
View File

@ -0,0 +1,164 @@
/**
* @author cktgh [chankaitung@gmail.com]
* @copyright Crown Copyright 2026
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import forge from "node-forge";
import Utils, { isWorkerEnvironment } from "../Utils.mjs";
import { DELIM_OPTIONS } from "../lib/Delim.mjs";
/**
* Pseudo-Random Integer Generator operation
*/
class PseudoRandomIntegerGenerator extends Operation {
// in theory 2**53 is the max range, but we use Number.MAX_SAFE_INTEGER (2**53 - 1) as it is more consistent.
static MAX_RANGE = Number.MAX_SAFE_INTEGER;
// arbitrary choice
static BUFFER_SIZE = 1024;
/**
* PseudoRandomIntegerGenerator constructor
*/
constructor() {
super();
this.name = "Pseudo-Random Integer Generator";
this.module = "Ciphers";
this.description = "A cryptographically-secure pseudo-random number generator (PRNG).<br><br>Generates random integers within a specified range using the browser's built-in <code>crypto.getRandomValues()</code> method if available.<br><br>The supported range of integers is from <code>-(2^53 - 1)</code> to <code>(2^53 - 1)</code>.";
this.infoURL = "https://wikipedia.org/wiki/Pseudorandom_number_generator";
this.inputType = "string";
this.outputType = "string";
this.args = [
{
"name": "Number of Integers",
"type": "number",
"value": 1,
"min": 1
},
{
"name": "Min Value",
"type": "number",
"value": 0,
"min": Number.MIN_SAFE_INTEGER,
"max": Number.MAX_SAFE_INTEGER
},
{
"name": "Max Value",
"type": "number",
"value": 99,
"min": Number.MIN_SAFE_INTEGER,
"max": Number.MAX_SAFE_INTEGER
},
{
"name": "Delimiter",
"type": "option",
"value": DELIM_OPTIONS
},
{
"name": "Output",
"type": "option",
"value": ["Raw", "Hex", "Decimal"]
}
];
// not using BigUint64Array to avoid BigInt handling overhead
this.randomBuffer = new Uint32Array(PseudoRandomIntegerGenerator.BUFFER_SIZE);
this.randomBufferOffset = PseudoRandomIntegerGenerator.BUFFER_SIZE;
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const [numInts, minInt, maxInt, delimiter, outputType] = args;
if (minInt === null || maxInt === null) return "";
const min = Math.ceil(minInt);
const max = Math.floor(maxInt);
const delim = Utils.charRep(delimiter || "Space");
if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {
throw new OperationError("Min and Max must be between `-(2^53 - 1)` and `2^53 - 1`.");
}
if (min > max) {
throw new OperationError("Min cannot be larger than Max.");
}
const range = max - min + 1; // inclusive range
if (range > PseudoRandomIntegerGenerator.MAX_RANGE) {
throw new OperationError("Range between Min and Max cannot be larger than `2^53`");
}
// as large as possible while divisible by range
const rejectionThreshold = PseudoRandomIntegerGenerator.MAX_RANGE - (PseudoRandomIntegerGenerator.MAX_RANGE % range);
const output = [];
for (let i = 0; i < numInts; i++) {
const result = this._generateRandomValue(rejectionThreshold);
const intValue = min + (result % range);
switch (outputType) {
case "Hex":
output.push(intValue.toString(16));
break;
case "Decimal":
output.push(intValue.toString(10));
break;
case "Raw":
default:
output.push(Utils.chr(intValue));
}
}
if (outputType === "Raw") {
return output.join("");
}
return output.join(delim);
}
/**
* Generate a random value, result will be less than the rejection threshold (exclusive).
*
* @param {number} rejectionThreshold
* @returns {number}
*/
_generateRandomValue(rejectionThreshold) {
let result;
do {
if (this.randomBufferOffset + 2 > this.randomBuffer.length) {
this._resetRandomBuffer();
}
// stitching a 53 bit number; not using BigUint64Array to avoid BigInt handling overhead
result = (this.randomBuffer[this.randomBufferOffset++] & 0x1f_ffff) * 0x1_0000_0000 +
this.randomBuffer[this.randomBufferOffset++];
} while (result >= rejectionThreshold);
return result;
}
/**
* Fill random buffer with new random values and rseet the offset.
*/
_resetRandomBuffer() {
if (isWorkerEnvironment() && self.crypto) {
self.crypto.getRandomValues(this.randomBuffer);
} else {
const bytes = forge.random.getBytesSync(this.randomBuffer.length * 4);
for (let j = 0; j < this.randomBuffer.length; j++) {
this.randomBuffer[j] = (bytes.charCodeAt(j * 4) << 24) |
(bytes.charCodeAt(j * 4 + 1) << 16) |
(bytes.charCodeAt(j * 4 + 2) << 8) |
bytes.charCodeAt(j * 4 + 3);
}
}
this.randomBufferOffset = 0;
}
}
export default PseudoRandomIntegerGenerator;

7
src/core/operations/ROT13.mjs
View File

@ -59,15 +59,16 @@ class ROT13 extends Operation {
rot13Upperacse = args[1], rot13Upperacse = args[1],
rotNumbers = args[2]; rotNumbers = args[2];
let amount = args[3], let amount = args[3],
chr; amountNumbers = args[3];
if (amount) { if (amount) {
if (amount < 0) { if (amount < 0) {
amount = 26 - (Math.abs(amount) % 26); amount = 26 - (Math.abs(amount) % 26);
amountNumbers = 10 - (Math.abs(amountNumbers) % 10);
} }
for (let i = 0; i < input.length; i++) { for (let i = 0; i < input.length; i++) {
chr = input[i]; let chr = input[i];
if (rot13Upperacse && chr >= 65 && chr <= 90) { // Upper case if (rot13Upperacse && chr >= 65 && chr <= 90) { // Upper case
chr = (chr - 65 + amount) % 26; chr = (chr - 65 + amount) % 26;
output[i] = chr + 65; output[i] = chr + 65;
@ -75,7 +76,7 @@ class ROT13 extends Operation {
chr = (chr - 97 + amount) % 26; chr = (chr - 97 + amount) % 26;
output[i] = chr + 97; output[i] = chr + 97;
} else if (rotNumbers && chr >= 48 && chr <= 57) { // Numbers } else if (rotNumbers && chr >= 48 && chr <= 57) { // Numbers
chr = (chr - 48 + amount) % 10; chr = (chr - 48 + amountNumbers) % 10;
output[i] = chr + 48; output[i] = chr + 48;
} }
} }

2
src/core/operations/RailFenceCipherDecode.mjs
View File

@ -72,7 +72,7 @@ class RailFenceCipherDecode extends Operation {
} }
} }
return plaintext.join("").trim(); return plaintext.join("");
} }
} }

2
src/core/operations/RailFenceCipherEncode.mjs
View File

@ -66,7 +66,7 @@ class RailFenceCipherEncode extends Operation {
rows[rowIdx] += plaintext[pos]; rows[rowIdx] += plaintext[pos];
} }
return rows.join("").trim(); return rows.join("");
} }
} }

18
src/core/operations/RandomizeColourPalette.mjs
View File

@ -10,13 +10,12 @@ import Utils from "../Utils.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { runHash } from "../lib/Hash.mjs"; import { runHash } from "../lib/Hash.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp } from "jimp";
/** /**
* Randomize Colour Palette operation * Randomize Colour Palette operation
*/ */
class RandomizeColourPalette extends Operation { class RandomizeColourPalette extends Operation {
/** /**
* RandomizeColourPalette constructor * RandomizeColourPalette constructor
*/ */
@ -25,7 +24,8 @@ class RandomizeColourPalette extends Operation {
this.name = "Randomize Colour Palette"; this.name = "Randomize Colour Palette";
this.module = "Image"; this.module = "Image";
this.description = "Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography."; this.description =
"Randomizes each colour in an image's colour palette. This can often reveal text or symbols that were previously a very similar colour to their surroundings, a technique sometimes used in Steganography.";
this.infoURL = "https://wikipedia.org/wiki/Indexed_color"; this.infoURL = "https://wikipedia.org/wiki/Indexed_color";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -34,8 +34,8 @@ class RandomizeColourPalette extends Operation {
{ {
name: "Seed", name: "Seed",
type: "string", type: "string",
value: "" value: "",
} },
]; ];
} }
@ -45,9 +45,10 @@ class RandomizeColourPalette extends Operation {
* @returns {ArrayBuffer} * @returns {ArrayBuffer}
*/ */
async run(input, args) { async run(input, args) {
if (!isImage(input)) throw new OperationError("Please enter a valid image file."); if (!isImage(input))
throw new OperationError("Please enter a valid image file.");
const seed = args[0] || (Math.random().toString().substr(2)), const seed = args[0] || Math.random().toString().substr(2),
parsedImage = await Jimp.read(input), parsedImage = await Jimp.read(input),
width = parsedImage.bitmap.width, width = parsedImage.bitmap.width,
height = parsedImage.bitmap.height; height = parsedImage.bitmap.height;
@ -61,7 +62,7 @@ class RandomizeColourPalette extends Operation {
parsedImage.setPixelColor(parseInt(rgbHex, 16), x, y); parsedImage.setPixelColor(parseInt(rgbHex, 16), x, y);
}); });
const imageBuffer = await parsedImage.getBufferAsync(Jimp.AUTO); const imageBuffer = await parsedImage.getBuffer(parsedImage.mime);
return new Uint8Array(imageBuffer).buffer; return new Uint8Array(imageBuffer).buffer;
} }
@ -77,7 +78,6 @@ class RandomizeColourPalette extends Operation {
return `<img src="data:${type};base64,${toBase64(data)}">`; return `<img src="data:${type};base64,${toBase64(data)}">`;
} }
} }
export default RandomizeColourPalette; export default RandomizeColourPalette;

53
src/core/operations/ResizeImage.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime, ResizeStrategy } from "jimp";
/** /**
* Resize Image operation * Resize Image operation
*/ */
class ResizeImage extends Operation { class ResizeImage extends Operation {
/** /**
* ResizeImage constructor * ResizeImage constructor
*/ */
@ -24,7 +23,8 @@ class ResizeImage extends Operation {
this.name = "Resize Image"; this.name = "Resize Image";
this.module = "Image"; this.module = "Image";
this.description = "Resizes an image to the specified width and height values."; this.description =
"Resizes an image to the specified width and height values.";
this.infoURL = "https://wikipedia.org/wiki/Image_scaling"; this.infoURL = "https://wikipedia.org/wiki/Image_scaling";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -34,23 +34,23 @@ class ResizeImage extends Operation {
name: "Width", name: "Width",
type: "number", type: "number",
value: 100, value: 100,
min: 1 min: 1,
}, },
{ {
name: "Height", name: "Height",
type: "number", type: "number",
value: 100, value: 100,
min: 1 min: 1,
}, },
{ {
name: "Unit type", name: "Unit type",
type: "option", type: "option",
value: ["Pixels", "Percent"] value: ["Pixels", "Percent"],
}, },
{ {
name: "Maintain aspect ratio", name: "Maintain aspect ratio",
type: "boolean", type: "boolean",
value: false value: false,
}, },
{ {
name: "Resizing algorithm", name: "Resizing algorithm",
@ -60,10 +60,10 @@ class ResizeImage extends Operation {
"Bilinear", "Bilinear",
"Bicubic", "Bicubic",
"Hermite", "Hermite",
"Bezier" "Bezier",
], ],
defaultIndex: 1 defaultIndex: 1,
} },
]; ];
} }
@ -80,11 +80,11 @@ class ResizeImage extends Operation {
resizeAlg = args[4]; resizeAlg = args[4];
const resizeMap = { const resizeMap = {
"Nearest Neighbour": Jimp.RESIZE_NEAREST_NEIGHBOR, "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
"Bilinear": Jimp.RESIZE_BILINEAR, Bilinear: ResizeStrategy.BILINEAR,
"Bicubic": Jimp.RESIZE_BICUBIC, Bicubic: ResizeStrategy.BICUBIC,
"Hermite": Jimp.RESIZE_HERMITE, Hermite: ResizeStrategy.HERMITE,
"Bezier": Jimp.RESIZE_BEZIER Bezier: ResizeStrategy.BEZIER,
}; };
if (!isImage(input)) { if (!isImage(input)) {
@ -99,23 +99,31 @@ class ResizeImage extends Operation {
} }
try { try {
if (unit === "Percent") { if (unit === "Percent") {
width = image.getWidth() * (width / 100); width = image.width * (width / 100);
height = image.getHeight() * (height / 100); height = image.height * (height / 100);
} }
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Resizing image..."); self.sendStatusMessage("Resizing image...");
if (aspect) { if (aspect) {
image.scaleToFit(width, height, resizeMap[resizeAlg]); image.scaleToFit({
w: width,
h: height,
mode: resizeMap[resizeAlg],
});
} else { } else {
image.resize(width, height, resizeMap[resizeAlg]); image.resize({
w: width,
h: height,
mode: resizeMap[resizeAlg],
});
} }
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -139,7 +147,6 @@ class ResizeImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default ResizeImage; export default ResizeImage;

17
src/core/operations/RotateImage.mjs
View File

@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Rotate Image operation * Rotate Image operation
*/ */
class RotateImage extends Operation { class RotateImage extends Operation {
/** /**
* RotateImage constructor * RotateImage constructor
*/ */
@ -24,7 +23,8 @@ class RotateImage extends Operation {
this.name = "Rotate Image"; this.name = "Rotate Image";
this.module = "Image"; this.module = "Image";
this.description = "Rotates an image by the specified number of degrees."; this.description =
"Rotates an image by the specified number of degrees.";
this.infoURL = ""; this.infoURL = "";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "ArrayBuffer"; this.outputType = "ArrayBuffer";
@ -33,8 +33,8 @@ class RotateImage extends Operation {
{ {
name: "Rotation amount (degrees)", name: "Rotation amount (degrees)",
type: "number", type: "number",
value: 90 value: 90,
} },
]; ];
} }
@ -62,10 +62,10 @@ class RotateImage extends Operation {
image.rotate(degrees); image.rotate(degrees);
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -89,7 +89,6 @@ class RotateImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default RotateImage; export default RotateImage;

71
src/core/operations/SM2Decrypt.mjs Normal file
View File

@ -0,0 +1,71 @@
/**
* @author flakjacket95 [dflack95@gmail.com]
* @copyright Crown Copyright 2024
* @license Apache-2.0
*/
import OperationError from "../errors/OperationError.mjs";
import Operation from "../Operation.mjs";
import { SM2 } from "../lib/SM2.mjs";
/**
* SM2Decrypt operation
*/
class SM2Decrypt extends Operation {
/**
* SM2Decrypt constructor
*/
constructor() {
super();
this.name = "SM2 Decrypt";
this.module = "Crypto";
this.description = "Decrypts a message utilizing the SM2 standard";
this.infoURL = ""; // Usually a Wikipedia link. Remember to remove localisation (i.e. https://wikipedia.org/etc rather than https://en.wikipedia.org/etc)
this.inputType = "string";
this.outputType = "ArrayBuffer";
this.args = [
{
name: "Private Key",
type: "string",
value: "DEADBEEF"
},
{
"name": "Input Format",
"type": "option",
"value": ["C1C3C2", "C1C2C3"],
"defaultIndex": 0
},
{
name: "Curve",
type: "option",
"value": ["sm2p256v1"],
"defaultIndex": 0
}
];
}
/**
* @param {string} input
* @param {Object[]} args
* @returns {ArrayBuffer}
*/
run(input, args) {
const [privateKey, inputFormat, curveName] = args;
if (privateKey.length !== 64) {
throw new OperationError("Input private key must be in hex; and should be 32 bytes");
}
const sm2 = new SM2(curveName, inputFormat);
sm2.setPrivateKey(privateKey);
const result = sm2.decrypt(input);
return result;
}
}
export default SM2Decrypt;

77
src/core/operations/SM2Encrypt.mjs Normal file
View File

@ -0,0 +1,77 @@
/**
* @author flakjacket95 [dflack95@gmail.com]
* @copyright Crown Copyright 2024
* @license Apache-2.0
*/
import OperationError from "../errors/OperationError.mjs";
import Operation from "../Operation.mjs";
import { SM2 } from "../lib/SM2.mjs";
/**
* SM2 Encrypt operation
*/
class SM2Encrypt extends Operation {
/**
* SM2Encrypt constructor
*/
constructor() {
super();
this.name = "SM2 Encrypt";
this.module = "Crypto";
this.description = "Encrypts a message utilizing the SM2 standard";
this.infoURL = ""; // Usually a Wikipedia link. Remember to remove localisation (i.e. https://wikipedia.org/etc rather than https://en.wikipedia.org/etc)
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [
{
name: "Public Key X",
type: "string",
value: "DEADBEEF"
},
{
name: "Public Key Y",
type: "string",
value: "DEADBEEF"
},
{
"name": "Output Format",
"type": "option",
"value": ["C1C3C2", "C1C2C3"],
"defaultIndex": 0
},
{
name: "Curve",
type: "option",
"value": ["sm2p256v1"],
"defaultIndex": 0
}
];
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {byteArray}
*/
run(input, args) {
const [publicKeyX, publicKeyY, outputFormat, curveName] = args;
this.outputFormat = outputFormat;
if (publicKeyX.length !== 64 || publicKeyY.length !== 64) {
throw new OperationError("Invalid Public Key - Ensure each component is 32 bytes in size and in hex");
}
const sm2 = new SM2(curveName, outputFormat);
sm2.setPublicKey(publicKeyX, publicKeyY);
const result = sm2.encrypt(new Uint8Array(input));
return result;
}
}
export default SM2Encrypt;

24
src/core/operations/SQLBeautify.mjs
View File

@ -3,8 +3,7 @@
* @copyright Crown Copyright 2016 * @copyright Crown Copyright 2016
* @license Apache-2.0 * @license Apache-2.0
*/ */
import { format } from "sql-formatter";
import vkbeautify from "vkbeautify";
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
/** /**
@ -39,7 +38,26 @@ class SQLBeautify extends Operation {
*/ */
run(input, args) { run(input, args) {
const indentStr = args[0]; const indentStr = args[0];
return vkbeautify.sql(input, indentStr); // Extract and replace bind variables like :Bind1 with __BIND_0__
const bindRegex = /:\w+/g;
const bindMap = {};
let bindCounter=0;
const placeholderInput = input.replace(bindRegex, (match) => {
const placeholder = `__BIND_${bindCounter++}__`;
bindMap[placeholder] = match;
return placeholder;
});
// Format the SQL with chosen options
let formatted= format(placeholderInput, {
language: "mysql", // Use MySQL as the default dialect for better compatibility with real-world SQL
useTabs: indentStr==="\t", // true if tab, false if spaces
tabWidth: indentStr.length || 4, // fallback if empty
indentStyle: "standard" // fine for most SQL
});
// Replace placeholders back with original bind variables
formatted = formatted.replace(/__BIND_\d+__/g, match => bindMap[match] || match);
return formatted;
} }
} }

88
src/core/operations/SharpenImage.mjs
View File

@ -8,15 +8,13 @@ import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs"; import OperationError from "../errors/OperationError.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import { toBase64 } from "../lib/Base64.mjs"; import { toBase64 } from "../lib/Base64.mjs";
import { gaussianBlur } from "../lib/ImageManipulation.mjs";
import { isWorkerEnvironment } from "../Utils.mjs"; import { isWorkerEnvironment } from "../Utils.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Sharpen Image operation * Sharpen Image operation
*/ */
class SharpenImage extends Operation { class SharpenImage extends Operation {
/** /**
* SharpenImage constructor * SharpenImage constructor
*/ */
@ -35,22 +33,22 @@ class SharpenImage extends Operation {
name: "Radius", name: "Radius",
type: "number", type: "number",
value: 2, value: 2,
min: 1 min: 1,
}, },
{ {
name: "Amount", name: "Amount",
type: "number", type: "number",
value: 1, value: 1,
min: 0, min: 0,
step: 0.1 step: 0.1,
}, },
{ {
name: "Threshold", name: "Threshold",
type: "number", type: "number",
value: 10, value: 10,
min: 0, min: 0,
max: 100 max: 100,
} },
]; ];
} }
@ -79,13 +77,21 @@ class SharpenImage extends Operation {
const blurMask = image.clone(); const blurMask = image.clone();
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Sharpening image... (Blurring cloned image)"); self.sendStatusMessage(
const blurImage = gaussianBlur(image.clone(), radius); "Sharpening image... (Blurring cloned image)",
);
const blurImage = image.clone().gaussian(radius);
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Sharpening image... (Creating unsharp mask)"); self.sendStatusMessage(
blurMask.scan(0, 0, blurMask.bitmap.width, blurMask.bitmap.height, function(x, y, idx) { "Sharpening image... (Creating unsharp mask)",
);
blurMask.scan(
0,
0,
blurMask.bitmap.width,
blurMask.bitmap.height,
function (x, y, idx) {
const blurRed = blurImage.bitmap.data[idx]; const blurRed = blurImage.bitmap.data[idx];
const blurGreen = blurImage.bitmap.data[idx + 1]; const blurGreen = blurImage.bitmap.data[idx + 1];
const blurBlue = blurImage.bitmap.data[idx + 2]; const blurBlue = blurImage.bitmap.data[idx + 2];
@ -95,14 +101,25 @@ class SharpenImage extends Operation {
const normalBlue = this.bitmap.data[idx + 2]; const normalBlue = this.bitmap.data[idx + 2];
// Subtract blurred pixel value from normal image // Subtract blurred pixel value from normal image
this.bitmap.data[idx] = (normalRed > blurRed) ? normalRed - blurRed : 0; this.bitmap.data[idx] =
this.bitmap.data[idx + 1] = (normalGreen > blurGreen) ? normalGreen - blurGreen : 0; normalRed > blurRed ? normalRed - blurRed : 0;
this.bitmap.data[idx + 2] = (normalBlue > blurBlue) ? normalBlue - blurBlue : 0; this.bitmap.data[idx + 1] =
}); normalGreen > blurGreen ? normalGreen - blurGreen : 0;
this.bitmap.data[idx + 2] =
normalBlue > blurBlue ? normalBlue - blurBlue : 0;
},
);
if (isWorkerEnvironment()) if (isWorkerEnvironment())
self.sendStatusMessage("Sharpening image... (Merging with unsharp mask)"); self.sendStatusMessage(
image.scan(0, 0, image.bitmap.width, image.bitmap.height, function(x, y, idx) { "Sharpening image... (Merging with unsharp mask)",
);
image.scan(
0,
0,
image.bitmap.width,
image.bitmap.height,
function (x, y, idx) {
let maskRed = blurMask.bitmap.data[idx]; let maskRed = blurMask.bitmap.data[idx];
let maskGreen = blurMask.bitmap.data[idx + 1]; let maskGreen = blurMask.bitmap.data[idx + 1];
let maskBlue = blurMask.bitmap.data[idx + 2]; let maskBlue = blurMask.bitmap.data[idx + 2];
@ -112,8 +129,14 @@ class SharpenImage extends Operation {
const normalBlue = this.bitmap.data[idx + 2]; const normalBlue = this.bitmap.data[idx + 2];
// Calculate luminance // Calculate luminance
const maskLuminance = (0.2126 * maskRed + 0.7152 * maskGreen + 0.0722 * maskBlue); const maskLuminance =
const normalLuminance = (0.2126 * normalRed + 0.7152 * normalGreen + 0.0722 * normalBlue); 0.2126 * maskRed +
0.7152 * maskGreen +
0.0722 * maskBlue;
const normalLuminance =
0.2126 * normalRed +
0.7152 * normalGreen +
0.0722 * normalBlue;
let luminanceDiff; let luminanceDiff;
if (maskLuminance > normalLuminance) { if (maskLuminance > normalLuminance) {
@ -129,17 +152,27 @@ class SharpenImage extends Operation {
// Only change pixel value if the difference is higher than threshold // Only change pixel value if the difference is higher than threshold
if ((luminanceDiff / 255) * 100 >= threshold) { if ((luminanceDiff / 255) * 100 >= threshold) {
this.bitmap.data[idx] = (normalRed + maskRed) <= 255 ? normalRed + maskRed : 255; this.bitmap.data[idx] =
this.bitmap.data[idx + 1] = (normalGreen + maskGreen) <= 255 ? normalGreen + maskGreen : 255; normalRed + maskRed <= 255 ?
this.bitmap.data[idx + 2] = (normalBlue + maskBlue) <= 255 ? normalBlue + maskBlue : 255; normalRed + maskRed :
255;
this.bitmap.data[idx + 1] =
normalGreen + maskGreen <= 255 ?
normalGreen + maskGreen :
255;
this.bitmap.data[idx + 2] =
normalBlue + maskBlue <= 255 ?
normalBlue + maskBlue :
255;
} }
}); },
);
let imageBuffer; let imageBuffer;
if (image.getMIME() === "image/gif") { if (image.mime === "image/gif") {
imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG); imageBuffer = await image.getBuffer(JimpMime.png);
} else { } else {
imageBuffer = await image.getBufferAsync(Jimp.AUTO); imageBuffer = await image.getBuffer(image.mime);
} }
return imageBuffer.buffer; return imageBuffer.buffer;
} catch (err) { } catch (err) {
@ -163,7 +196,6 @@ class SharpenImage extends Operation {
return `<img src="data:${type};base64,${toBase64(dataArray)}">`; return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
} }
} }
export default SharpenImage; export default SharpenImage;

13
src/core/operations/ShowOnMap.mjs
View File

@ -1,6 +1,7 @@
/** /**
* @author j433866 [j433866@gmail.com] * @author j433866 [j433866@gmail.com]
* @copyright Crown Copyright 2019 * @author 0xff1ce [github.com/0xff1ce]
* @copyright Crown Copyright 2024
* @license Apache-2.0 * @license Apache-2.0
*/ */
@ -22,7 +23,7 @@ class ShowOnMap extends Operation {
this.name = "Show on map"; this.name = "Show on map";
this.module = "Hashing"; this.module = "Hashing";
this.description = "Displays co-ordinates on a slippy map.<br><br>Co-ordinates will be converted to decimal degrees before being shown on the map.<br><br>Supported formats:<ul><li>Degrees Minutes Seconds (DMS)</li><li>Degrees Decimal Minutes (DDM)</li><li>Decimal Degrees (DD)</li><li>Geohash</li><li>Military Grid Reference System (MGRS)</li><li>Ordnance Survey National Grid (OSNG)</li><li>Universal Transverse Mercator (UTM)</li></ul><br>This operation will not work offline."; this.description = "Displays co-ordinates on a slippy map.<br><br>Co-ordinates will be converted to decimal degrees before being shown on the map.<br><br>Supported formats:<ul><li>Degrees Minutes Seconds (DMS)</li><li>Degrees Decimal Minutes (DDM)</li><li>Decimal Degrees (DD)</li><li>Geohash</li><li>Military Grid Reference System (MGRS)</li><li>Ordnance Survey National Grid (OSNG)</li><li>Universal Transverse Mercator (UTM)</li></ul><br>This operation will not work offline.";
this.infoURL = "https://foundation.wikimedia.org/wiki/Maps_Terms_of_Use"; this.infoURL = "https://osmfoundation.org/wiki/Terms_of_Use";
this.inputType = "string"; this.inputType = "string";
this.outputType = "string"; this.outputType = "string";
this.presentType = "html"; this.presentType = "html";
@ -85,10 +86,10 @@ class ShowOnMap extends Operation {
data = "0, 0"; data = "0, 0";
} }
const zoomLevel = args[0]; const zoomLevel = args[0];
const tileUrl = "https://maps.wikimedia.org/osm-intl/{z}/{x}/{y}.png", const tileUrl = "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
tileAttribution = "<a href=\"https://wikimediafoundation.org/wiki/Maps_Terms_of_Use\">Wikimedia maps</a> | &copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors", tileAttribution = "&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors",
leafletUrl = "https://unpkg.com/leaflet@1.5.0/dist/leaflet.js", leafletUrl = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.js",
leafletCssUrl = "https://unpkg.com/leaflet@1.5.0/dist/leaflet.css"; leafletCssUrl = "https://unpkg.com/leaflet@1.9.4/dist/leaflet.css";
return `<link rel="stylesheet" href="${leafletCssUrl}" crossorigin=""/> return `<link rel="stylesheet" href="${leafletCssUrl}" crossorigin=""/>
<style> <style>
#output-text .cm-content, #output-text .cm-content,

56
src/core/operations/SplitColourChannels.mjs
View File

@ -8,13 +8,12 @@ import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs"; import OperationError from "../errors/OperationError.mjs";
import Utils from "../Utils.mjs"; import Utils from "../Utils.mjs";
import { isImage } from "../lib/FileType.mjs"; import { isImage } from "../lib/FileType.mjs";
import Jimp from "jimp/es/index.js"; import { Jimp, JimpMime } from "jimp";
/** /**
* Split Colour Channels operation * Split Colour Channels operation
*/ */
class SplitColourChannels extends Operation { class SplitColourChannels extends Operation {
/** /**
* SplitColourChannels constructor * SplitColourChannels constructor
*/ */
@ -23,7 +22,8 @@ class SplitColourChannels extends Operation {
this.name = "Split Colour Channels"; this.name = "Split Colour Channels";
this.module = "Image"; this.module = "Image";
this.description = "Splits the given image into its red, green and blue colour channels."; this.description =
"Splits the given image into its red, green and blue colour channels.";
this.infoURL = "https://wikipedia.org/wiki/Channel_(digital_image)"; this.infoURL = "https://wikipedia.org/wiki/Channel_(digital_image)";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "List<File>"; this.outputType = "List<File>";
@ -49,25 +49,43 @@ class SplitColourChannels extends Operation {
.clone() .clone()
.color([ .color([
{ apply: "blue", params: [-255] }, { apply: "blue", params: [-255] },
{apply: "green", params: [-255]} { apply: "green", params: [-255] },
]) ])
.getBufferAsync(Jimp.MIME_PNG); .getBuffer(JimpMime.png);
resolve(new File([new Uint8Array((await split).values())], "red.png", {type: "image/png"})); resolve(
new File(
[new Uint8Array((await split).values())],
"red.png",
{ type: "image/png" },
),
);
} catch (err) { } catch (err) {
reject(new OperationError(`Could not split red channel: ${err}`)); reject(
new OperationError(`Could not split red channel: ${err}`),
);
} }
}); });
const green = new Promise(async (resolve, reject) => { const green = new Promise(async (resolve, reject) => {
try { try {
const split = parsedImage.clone() const split = parsedImage
.clone()
.color([ .color([
{ apply: "red", params: [-255] }, { apply: "red", params: [-255] },
{ apply: "blue", params: [-255] }, { apply: "blue", params: [-255] },
]).getBufferAsync(Jimp.MIME_PNG); ])
resolve(new File([new Uint8Array((await split).values())], "green.png", {type: "image/png"})); .getBuffer(JimpMime.png);
resolve(
new File(
[new Uint8Array((await split).values())],
"green.png",
{ type: "image/png" },
),
);
} catch (err) { } catch (err) {
reject(new OperationError(`Could not split green channel: ${err}`)); reject(
new OperationError(`Could not split green channel: ${err}`),
);
} }
}); });
@ -77,10 +95,19 @@ class SplitColourChannels extends Operation {
.color([ .color([
{ apply: "red", params: [-255] }, { apply: "red", params: [-255] },
{ apply: "green", params: [-255] }, { apply: "green", params: [-255] },
]).getBufferAsync(Jimp.MIME_PNG); ])
resolve(new File([new Uint8Array((await split).values())], "blue.png", {type: "image/png"})); .getBuffer(JimpMime.png);
resolve(
new File(
[new Uint8Array((await split).values())],
"blue.png",
{ type: "image/png" },
),
);
} catch (err) { } catch (err) {
reject(new OperationError(`Could not split blue channel: ${err}`)); reject(
new OperationError(`Could not split blue channel: ${err}`),
);
} }
}); });
@ -96,7 +123,6 @@ class SplitColourChannels extends Operation {
async present(files) { async present(files) {
return await Utils.displayFilesAsHTML(files); return await Utils.displayFilesAsHTML(files);
} }
} }
export default SplitColourChannels; export default SplitColourChannels;

53
src/core/operations/Template.mjs Normal file
View File

@ -0,0 +1,53 @@
/**
* @author kendallgoto [k@kgo.to]
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import OperationError from "../errors/OperationError.mjs";
import Handlebars from "handlebars";
/**
* Template operation
*/
class Template extends Operation {
/**
* Template constructor
*/
constructor() {
super();
this.name = "Template";
this.module = "Handlebars";
this.description = "Render a template with Handlebars/Mustache substituting variables using JSON input. Templates will be rendered to plain-text only, to prevent XSS.";
this.infoURL = "https://handlebarsjs.com/";
this.inputType = "JSON";
this.outputType = "string";
this.args = [
{
name: "Template definition (.handlebars)",
type: "text",
value: ""
}
];
}
/**
* @param {JSON} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const [templateStr] = args;
try {
const template = Handlebars.compile(templateStr);
return template(input);
} catch (e) {
throw new OperationError(e);
}
}
}
export default Template;

6
src/core/operations/ToBase32.mjs
View File

@ -6,6 +6,7 @@
import Operation from "../Operation.mjs"; import Operation from "../Operation.mjs";
import Utils from "../Utils.mjs"; import Utils from "../Utils.mjs";
import {ALPHABET_OPTIONS} from "../lib/Base32.mjs";
/** /**
* To Base32 operation * To Base32 operation
@ -27,8 +28,8 @@ class ToBase32 extends Operation {
this.args = [ this.args = [
{ {
name: "Alphabet", name: "Alphabet",
type: "binaryString", type: "editableOption",
value: "A-Z2-7=" value: ALPHABET_OPTIONS
} }
]; ];
} }
@ -83,3 +84,4 @@ class ToBase32 extends Operation {
} }
export default ToBase32; export default ToBase32;

2
src/core/operations/ToBase85.mjs
View File

@ -33,7 +33,7 @@ class ToBase85 extends Operation {
value: ALPHABET_OPTIONS value: ALPHABET_OPTIONS
}, },
{ {
name: "Include delimeter", name: "Include delimiter",
type: "boolean", type: "boolean",
value: false value: false
} }

92
src/core/operations/ToBech32.mjs Normal file
View File

@ -0,0 +1,92 @@
/**
* @author Medjedtxm
* @copyright Crown Copyright 2025
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import { encode } from "../lib/Bech32.mjs";
import { fromHex } from "../lib/Hex.mjs";
/**
* To Bech32 operation
*/
class ToBech32 extends Operation {
/**
* ToBech32 constructor
*/
constructor() {
super();
this.name = "To Bech32";
this.module = "Default";
this.description = "Bech32 is an encoding scheme primarily used for Bitcoin SegWit addresses (BIP-0173). It uses a 32-character alphabet that excludes easily confused characters (1, b, i, o) and includes a checksum for error detection.<br><br>Bech32m (BIP-0350) is an updated version that fixes a weakness in the original Bech32 checksum and is used for Bitcoin Taproot addresses.<br><br>The Human-Readable Part (HRP) identifies the network or purpose (e.g., 'bc' for Bitcoin mainnet, 'tb' for testnet, 'age' for AGE encryption keys).<br><br>Maximum output length is 90 characters as per specification.";
this.infoURL = "https://wikipedia.org/wiki/Bech32";
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [
{
"name": "Human-Readable Part (HRP)",
"type": "string",
"value": "bc"
},
{
"name": "Encoding",
"type": "option",
"value": ["Bech32", "Bech32m"]
},
{
"name": "Input Format",
"type": "option",
"value": ["Raw bytes", "Hex"]
},
{
"name": "Mode",
"type": "option",
"value": ["Generic", "Bitcoin SegWit"]
},
{
"name": "Witness Version",
"type": "number",
"value": 0,
"hint": "SegWit witness version (0-16). Only used in Bitcoin SegWit mode."
}
];
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const hrp = args[0];
const encoding = args[1];
const inputFormat = args[2];
const mode = args[3];
const witnessVersion = args[4];
let inputArray;
if (inputFormat === "Hex") {
// Convert hex string to bytes
const hexStr = new TextDecoder().decode(new Uint8Array(input)).replace(/\s/g, "");
inputArray = fromHex(hexStr);
} else {
inputArray = new Uint8Array(input);
}
if (mode === "Bitcoin SegWit") {
// Prepend witness version to the input data
const withVersion = new Uint8Array(inputArray.length + 1);
withVersion[0] = witnessVersion;
withVersion.set(inputArray, 1);
return encode(hrp, withVersion, encoding, true);
}
return encode(hrp, inputArray, encoding, false);
}
}
export default ToBech32;

5
src/core/operations/ToDecimal.mjs
View File

@ -45,11 +45,12 @@ class ToDecimal extends Operation {
* @returns {string} * @returns {string}
*/ */
run(input, args) { run(input, args) {
input = new Uint8Array(input);
const delim = Utils.charRep(args[0]), const delim = Utils.charRep(args[0]),
signed = args[1]; signed = args[1];
if (signed) { if (signed) {
input = input.map(v => v > 0x7F ? v - 0xFF - 1 : v); input = new Int8Array(input);
} else {
input = new Uint8Array(input);
} }
return input.join(delim); return input.join(delim);
} }

55
src/core/operations/ToModhex.mjs Normal file
View File

@ -0,0 +1,55 @@
/**
* @author linuxgemini [ilteris@asenkron.com.tr]
* @copyright Crown Copyright 2024
* @license Apache-2.0
*/
import Operation from "../Operation.mjs";
import { TO_MODHEX_DELIM_OPTIONS, toModhex } from "../lib/Modhex.mjs";
import Utils from "../Utils.mjs";
/**
* To Modhex operation
*/
class ToModhex extends Operation {
/**
* ToModhex constructor
*/
constructor() {
super();
this.name = "To Modhex";
this.module = "Default";
this.description = "Converts the input string to modhex bytes separated by the specified delimiter.";
this.infoURL = "https://en.wikipedia.org/wiki/YubiKey#ModHex";
this.inputType = "ArrayBuffer";
this.outputType = "string";
this.args = [
{
name: "Delimiter",
type: "option",
value: TO_MODHEX_DELIM_OPTIONS
},
{
name: "Bytes per line",
type: "number",
value: 0
}
];
}
/**
* @param {ArrayBuffer} input
* @param {Object[]} args
* @returns {string}
*/
run(input, args) {
const delim = Utils.charRep(args[0]);
const lineSize = args[1];
return toModhex(new Uint8Array(input), delim, 2, "", lineSize);
}
}
export default ToModhex;

2
src/core/operations/ToQuotedPrintable.mjs
View File

@ -23,7 +23,7 @@ class ToQuotedPrintable extends Operation {
this.name = "To Quoted Printable"; this.name = "To Quoted Printable";
this.module = "Default"; this.module = "Default";
this.description = "Quoted-Printable, or QP encoding, is an encoding using printable ASCII characters (alphanumeric and the equals sign '=') to transmit 8-bit data over a 7-bit data path or, generally, over a medium which is not 8-bit clean. It is defined as a MIME content transfer encoding for use in e-mail.<br><br>QP works by using the equals sign '=' as an escape character. It also limits line length to 76, as some software has limits on line length."; this.description = "Quoted-Printable, or QP encoding, is an encoding using printable ASCII characters (alphanumeric and the equals sign '=') to transmit 8-bit data over a 7-bit data path or, generally, over a medium which is not 8-bit clean. It is defined as a MIME content transfer encoding for use in email.<br><br>QP works by using the equals sign '=' as an escape character. It also limits line length to 76, as some software has limits on line length.";
this.infoURL = "https://wikipedia.org/wiki/Quoted-printable"; this.infoURL = "https://wikipedia.org/wiki/Quoted-printable";
this.inputType = "ArrayBuffer"; this.inputType = "ArrayBuffer";
this.outputType = "string"; this.outputType = "string";

Some files were not shown because too many files have changed in this diff Show More