├── .gitattributes
├── .gitignore
├── .travis.yml
├── LICENSE
├── Multiformats.Hash.sln
├── NuGet.config
├── README.md
├── appveyor.yml
├── build.sh
├── multihash
├── src
├── Multiformats.Hash.Benchmarks
│ ├── Multiformats.Hash.Benchmarks.csproj
│ ├── Program.cs
│ └── SumBenchmarks.cs
├── Multiformats.Hash.CLI
│ ├── Multiformats.Hash.CLI.csproj
│ └── Program.cs
└── Multiformats.Hash
│ ├── Algorithms
│ ├── BLAKE2B.cs
│ ├── BLAKE2B.tt
│ ├── BLAKE2S.cs
│ ├── BLAKE2S.tt
│ ├── DBL_SHA2_256.cs
│ ├── Extensions.cs
│ ├── ID.cs
│ ├── KECCAK.cs
│ ├── KECCAK.tt
│ ├── MD4.cs
│ ├── MD5.cs
│ ├── MURMUR3.cs
│ ├── MultihashAlgorithm.cs
│ ├── Registry.cs
│ ├── SHA1.cs
│ ├── SHA2.cs
│ ├── SHA2.tt
│ ├── SHA3.cs
│ ├── SHA3.tt
│ ├── SHAKE.cs
│ ├── SHAKE.tt
│ ├── SKEIN.cs
│ └── SKEIN.tt
│ ├── Extensions.cs
│ ├── HashType.cs
│ ├── HashType.tt
│ ├── Multiformats.Hash.csproj
│ └── Multihash.cs
└── test
└── Multiformats.Hash.Tests
├── ExtensionTests.cs
├── Multiformats.Hash.Tests.csproj
├── MultihashTests.cs
└── SumTests.cs
/.gitattributes:
--------------------------------------------------------------------------------
1 | ###############################################################################
2 | # Set default behavior to automatically normalize line endings.
3 | ###############################################################################
4 | * text=auto
5 |
6 | ###############################################################################
7 | # Set default behavior for command prompt diff.
8 | #
9 | # This is need for earlier builds of msysgit that does not have it on by
10 | # default for csharp files.
11 | # Note: This is only used by command line
12 | ###############################################################################
13 | #*.cs diff=csharp
14 |
15 | ###############################################################################
16 | # Set the merge driver for project and solution files
17 | #
18 | # Merging from the command prompt will add diff markers to the files if there
19 | # are conflicts (Merging from VS is not affected by the settings below, in VS
20 | # the diff markers are never inserted). Diff markers may cause the following
21 | # file extensions to fail to load in VS. An alternative would be to treat
22 | # these files as binary and thus will always conflict and require user
23 | # intervention with every merge. To do so, just uncomment the entries below
24 | ###############################################################################
25 | #*.sln merge=binary
26 | #*.csproj merge=binary
27 | #*.vbproj merge=binary
28 | #*.vcxproj merge=binary
29 | #*.vcproj merge=binary
30 | #*.dbproj merge=binary
31 | #*.fsproj merge=binary
32 | #*.lsproj merge=binary
33 | #*.wixproj merge=binary
34 | #*.modelproj merge=binary
35 | #*.sqlproj merge=binary
36 | #*.wwaproj merge=binary
37 |
38 | ###############################################################################
39 | # behavior for image files
40 | #
41 | # image files are treated as binary by default.
42 | ###############################################################################
43 | #*.jpg binary
44 | #*.png binary
45 | #*.gif binary
46 |
47 | ###############################################################################
48 | # diff behavior for common document formats
49 | #
50 | # Convert binary document formats to text before diffing them. This feature
51 | # is only available from the command line. Turn it on by uncommenting the
52 | # entries below.
53 | ###############################################################################
54 | #*.doc diff=astextplain
55 | #*.DOC diff=astextplain
56 | #*.docx diff=astextplain
57 | #*.DOCX diff=astextplain
58 | #*.dot diff=astextplain
59 | #*.DOT diff=astextplain
60 | #*.pdf diff=astextplain
61 | #*.PDF diff=astextplain
62 | #*.rtf diff=astextplain
63 | #*.RTF diff=astextplain
64 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | ## Ignore Visual Studio temporary files, build results, and
2 | ## files generated by popular Visual Studio add-ons.
3 |
4 | # User-specific files
5 | *.suo
6 | *.user
7 | *.userosscache
8 | *.sln.docstates
9 |
10 | # User-specific files (MonoDevelop/Xamarin Studio)
11 | *.userprefs
12 |
13 | # Build results
14 | [Dd]ebug/
15 | [Dd]ebugPublic/
16 | [Rr]elease/
17 | [Rr]eleases/
18 | [Xx]64/
19 | [Xx]86/
20 | [Bb]uild/
21 | bld/
22 | [Bb]in/
23 | [Oo]bj/
24 |
25 | # Visual Studio 2015 cache/options directory
26 | .vs/
27 | # Uncomment if you have tasks that create the project's static files in wwwroot
28 | #wwwroot/
29 |
30 | # MSTest test Results
31 | [Tt]est[Rr]esult*/
32 | [Bb]uild[Ll]og.*
33 |
34 | # NUNIT
35 | *.VisualState.xml
36 | TestResult.xml
37 |
38 | # Build Results of an ATL Project
39 | [Dd]ebugPS/
40 | [Rr]eleasePS/
41 | dlldata.c
42 |
43 | # DNX
44 | project.lock.json
45 | artifacts/
46 |
47 | *_i.c
48 | *_p.c
49 | *_i.h
50 | *.ilk
51 | *.meta
52 | *.obj
53 | *.pch
54 | *.pdb
55 | *.pgc
56 | *.pgd
57 | *.rsp
58 | *.sbr
59 | *.tlb
60 | *.tli
61 | *.tlh
62 | *.tmp
63 | *.tmp_proj
64 | *.log
65 | *.vspscc
66 | *.vssscc
67 | .builds
68 | *.pidb
69 | *.svclog
70 | *.scc
71 |
72 | # Chutzpah Test files
73 | _Chutzpah*
74 |
75 | # Visual C++ cache files
76 | ipch/
77 | *.aps
78 | *.ncb
79 | *.opendb
80 | *.opensdf
81 | *.sdf
82 | *.cachefile
83 | *.VC.db
84 |
85 | # Visual Studio profiler
86 | *.psess
87 | *.vsp
88 | *.vspx
89 | *.sap
90 |
91 | # TFS 2012 Local Workspace
92 | $tf/
93 |
94 | # Guidance Automation Toolkit
95 | *.gpState
96 |
97 | # ReSharper is a .NET coding add-in
98 | _ReSharper*/
99 | *.[Rr]e[Ss]harper
100 | *.DotSettings.user
101 |
102 | # JustCode is a .NET coding add-in
103 | .JustCode
104 |
105 | # TeamCity is a build add-in
106 | _TeamCity*
107 |
108 | # DotCover is a Code Coverage Tool
109 | *.dotCover
110 |
111 | # NCrunch
112 | _NCrunch_*
113 | .*crunch*.local.xml
114 | nCrunchTemp_*
115 |
116 | # MightyMoose
117 | *.mm.*
118 | AutoTest.Net/
119 |
120 | # Web workbench (sass)
121 | .sass-cache/
122 |
123 | # Installshield output folder
124 | [Ee]xpress/
125 |
126 | # DocProject is a documentation generator add-in
127 | DocProject/buildhelp/
128 | DocProject/Help/*.HxT
129 | DocProject/Help/*.HxC
130 | DocProject/Help/*.hhc
131 | DocProject/Help/*.hhk
132 | DocProject/Help/*.hhp
133 | DocProject/Help/Html2
134 | DocProject/Help/html
135 |
136 | # Click-Once directory
137 | publish/
138 |
139 | # Publish Web Output
140 | *.[Pp]ublish.xml
141 | *.azurePubxml
142 |
143 | # TODO: Un-comment the next line if you do not want to checkin
144 | # your web deploy settings because they may include unencrypted
145 | # passwords
146 | #*.pubxml
147 | *.publishproj
148 |
149 | # NuGet Packages
150 | *.nupkg
151 | # The packages folder can be ignored because of Package Restore
152 | **/packages/*
153 | # except build/, which is used as an MSBuild target.
154 | !**/packages/build/
155 | # Uncomment if necessary however generally it will be regenerated when needed
156 | #!**/packages/repositories.config
157 | # NuGet v3's project.json files produces more ignoreable files
158 | *.nuget.props
159 | *.nuget.targets
160 |
161 | # Microsoft Azure Build Output
162 | csx/
163 | *.build.csdef
164 |
165 | # Microsoft Azure Emulator
166 | ecf/
167 | rcf/
168 |
169 | # Windows Store app package directory
170 | AppPackages/
171 | BundleArtifacts/
172 |
173 | # Visual Studio cache files
174 | # files ending in .cache can be ignored
175 | *.[Cc]ache
176 | # but keep track of directories ending in .cache
177 | !*.[Cc]ache/
178 |
179 | # Others
180 | ClientBin/
181 | [Ss]tyle[Cc]op.*
182 | ~$*
183 | *~
184 | *.dbmdl
185 | *.dbproj.schemaview
186 | *.pfx
187 | *.publishsettings
188 | node_modules/
189 | orleans.codegen.cs
190 |
191 | # RIA/Silverlight projects
192 | Generated_Code/
193 |
194 | # Backup & report files from converting an old project file
195 | # to a newer Visual Studio version. Backup files are not needed,
196 | # because we have git ;-)
197 | _UpgradeReport_Files/
198 | Backup*/
199 | UpgradeLog*.XML
200 | UpgradeLog*.htm
201 |
202 | # SQL Server files
203 | *.mdf
204 | *.ldf
205 |
206 | # Business Intelligence projects
207 | *.rdl.data
208 | *.bim.layout
209 | *.bim_*.settings
210 |
211 | # Microsoft Fakes
212 | FakesAssemblies/
213 |
214 | # GhostDoc plugin setting file
215 | *.GhostDoc.xml
216 |
217 | # Node.js Tools for Visual Studio
218 | .ntvs_analysis.dat
219 |
220 | # Visual Studio 6 build log
221 | *.plg
222 |
223 | # Visual Studio 6 workspace options file
224 | *.opt
225 |
226 | # Visual Studio LightSwitch build output
227 | **/*.HTMLClient/GeneratedArtifacts
228 | **/*.DesktopClient/GeneratedArtifacts
229 | **/*.DesktopClient/ModelManifest.xml
230 | **/*.Server/GeneratedArtifacts
231 | **/*.Server/ModelManifest.xml
232 | _Pvt_Extensions
233 |
234 | # LightSwitch generated files
235 | GeneratedArtifacts/
236 | ModelManifest.xml
237 |
238 | # Paket dependency manager
239 | .paket/paket.exe
240 |
241 | # FAKE - F# Make
242 | .fake/
243 |
244 | .vscode/
245 |
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: csharp
2 | solution: Multiformats.Hash.sln
3 |
4 | matrix:
5 | include:
6 | - dotnet: 2.2.300
7 | dist: xenial
8 | mono: none
9 | env: DOTNET=1 CLI_VERSION=latest MULTIHASH_BIN="${TRAVIS_BUILD_DIR}/multihash" TEST_EXPENSIVE=1
10 | os: linux
11 | - mono: latest
12 | env: MONO=1 CLI_VERSION=latest MULTIHASH_BIN="${TRAVIS_BUILD_DIR}/multihash" TEST_EXPENSIVE=1
13 | os: linux
14 | - dotnet: 2.2.300
15 | dist: xenial
16 | mono: none
17 | env: DOTNET=1 CLI_VERSION=latest MULTIHASH_BIN="${TRAVIS_BUILD_DIR}/multihash" TEST_EXPENSIVE=1
18 | os: osx
19 | - mono: latest
20 | env: MONO=1 CLI_VERSION=latest MULTIHASH_BIN="${TRAVIS_BUILD_DIR}/multihash" TEST_EXPENSIVE=1
21 | os: osx
22 |
23 | notifications:
24 | email:
25 | on_success: change
26 | on_failure: always
27 |
28 | branches:
29 | only:
30 | - master
31 |
32 | cache:
33 | bundler: true
34 | directories:
35 | - ./packages
36 | - /.dotnetcli
37 | - $HOME/Library/Caches/Homebrew
38 |
39 | before_install:
40 | - if test "$TRAVIS_OS_NAME" == "osx"; then brew update; brew install openssl; ln -s /usr/local/opt/openssl/lib/libcrypto.1.0.0.dylib /usr/local/lib/; ln -s /usr/local/opt/openssl/lib/libssl.1.0.0.dylib /usr/local/lib/; fi
41 |
42 | install:
43 | - git config --global core.autocrlf input
44 | - chmod +x ./build.sh
45 | - mkdir ./sharness
46 | - git clone https://github.com/multiformats/multihash.git ./sharness
47 | - chmod +x ./multihash
48 |
49 | script:
50 | - ./build.sh
51 | - ./multihash --version
52 | - make -j1 -C ./sharness/tests/sharness
53 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/multiformats/cs-multihash/13eff29b070484bd8403ab380d9cc6de9e3e4738/LICENSE
--------------------------------------------------------------------------------
/Multiformats.Hash.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 12.00
3 | # Visual Studio 15
4 | VisualStudioVersion = 15.0.27130.2027
5 | MinimumVisualStudioVersion = 10.0.40219.1
6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Multiformats.Hash", "src\Multiformats.Hash\Multiformats.Hash.csproj", "{86A29D9B-0640-4AF4-985B-CB3085C87693}"
7 | EndProject
8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Multiformats.Hash.Tests", "test\Multiformats.Hash.Tests\Multiformats.Hash.Tests.csproj", "{00E6BCB9-A356-48B1-A84E-D6F293079EA6}"
9 | EndProject
10 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{E1DD8484-EFAE-4B0E-A815-8C42EBC86604}"
11 | ProjectSection(SolutionItems) = preProject
12 | .travis.yml = .travis.yml
13 | appveyor.yml = appveyor.yml
14 | build.sh = build.sh
15 | LICENSE = LICENSE
16 | multihash = multihash
17 | README.md = README.md
18 | EndProjectSection
19 | EndProject
20 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Multiformats.Hash.Benchmarks", "src\Multiformats.Hash.Benchmarks\Multiformats.Hash.Benchmarks.csproj", "{DE652359-F094-4C4D-A9C5-7EDAE216D0F6}"
21 | EndProject
22 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Multiformats.Hash.CLI", "src\Multiformats.Hash.CLI\Multiformats.Hash.CLI.csproj", "{234B6C7D-472D-4DDB-9617-FBD9F4E146F5}"
23 | EndProject
24 | Global
25 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
26 | Debug|Any CPU = Debug|Any CPU
27 | Debug|x64 = Debug|x64
28 | Release|Any CPU = Release|Any CPU
29 | Release|x64 = Release|x64
30 | EndGlobalSection
31 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
32 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
33 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Debug|Any CPU.Build.0 = Debug|Any CPU
34 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Debug|x64.ActiveCfg = Debug|Any CPU
35 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Debug|x64.Build.0 = Debug|Any CPU
36 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Release|Any CPU.ActiveCfg = Debug|Any CPU
37 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Release|Any CPU.Build.0 = Debug|Any CPU
38 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Release|x64.ActiveCfg = Debug|Any CPU
39 | {86A29D9B-0640-4AF4-985B-CB3085C87693}.Release|x64.Build.0 = Debug|Any CPU
40 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
41 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Debug|Any CPU.Build.0 = Debug|Any CPU
42 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Debug|x64.ActiveCfg = Debug|Any CPU
43 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Debug|x64.Build.0 = Debug|Any CPU
44 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Release|Any CPU.ActiveCfg = Debug|Any CPU
45 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Release|Any CPU.Build.0 = Debug|Any CPU
46 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Release|x64.ActiveCfg = Debug|Any CPU
47 | {00E6BCB9-A356-48B1-A84E-D6F293079EA6}.Release|x64.Build.0 = Debug|Any CPU
48 | {DE652359-F094-4C4D-A9C5-7EDAE216D0F6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
49 | {DE652359-F094-4C4D-A9C5-7EDAE216D0F6}.Debug|x64.ActiveCfg = Debug|Any CPU
50 | {DE652359-F094-4C4D-A9C5-7EDAE216D0F6}.Release|Any CPU.ActiveCfg = Debug|Any CPU
51 | {DE652359-F094-4C4D-A9C5-7EDAE216D0F6}.Release|x64.ActiveCfg = Debug|Any CPU
52 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
53 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Debug|Any CPU.Build.0 = Debug|Any CPU
54 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Debug|x64.ActiveCfg = Debug|Any CPU
55 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Debug|x64.Build.0 = Debug|Any CPU
56 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Release|Any CPU.ActiveCfg = Debug|Any CPU
57 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Release|Any CPU.Build.0 = Debug|Any CPU
58 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Release|x64.ActiveCfg = Debug|Any CPU
59 | {234B6C7D-472D-4DDB-9617-FBD9F4E146F5}.Release|x64.Build.0 = Debug|Any CPU
60 | EndGlobalSection
61 | GlobalSection(SolutionProperties) = preSolution
62 | HideSolutionNode = FALSE
63 | EndGlobalSection
64 | GlobalSection(ExtensibilityGlobals) = postSolution
65 | SolutionGuid = {1D1222E2-925D-48D8-B240-95E98929EBA6}
66 | EndGlobalSection
67 | EndGlobal
68 |
--------------------------------------------------------------------------------
/NuGet.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | **This project is no longer maintained and has been archived.**
2 |
3 | # Multiformats.Hash (cs-multihash)
4 |
5 | [](https://github.com/multiformats/multiformats)
6 | [](https://webchat.freenode.net/?channels=%23ipfs)
7 | [](https://travis-ci.org/multiformats/cs-multihash)
8 | [](https://ci.appveyor.com/project/tabrath/cs-multihash)
9 | [](https://www.nuget.org/packages/Multiformats.Hash/)
10 | [](https://github.com/RichardLitt/standard-readme)
11 | [](https://codecov.io/gh/multiformats/cs-multihash)
12 | [](https://libraries.io/github/multiformats/cs-multihash)
13 |
14 | > [Multihash](https://github.com/multiformats/multihash) implementation in C# .NET Standard 1.6 compliant.
15 |
16 | This is not a general purpose hashing library, but a library to encode/decode Multihashes which is a "container" describing what hash algorithm the digest is calculated with. The library also support calculating the digest, but that is not it's main purpose. If you're looking for a library that supports many algorithms and only want the raw digest, try BouncyCastle or the built-ins of the .net framework.
17 |
18 | To be clear, when you calculate a digest (using Sum) with this library, you will get a byte array including a prefix with the properties of the algorithm used (type and length).
19 |
20 | There's a CLI version that you can use to compute files or direct input from the command line.
21 | This CLI tool passes the sharness tests [here](https://github.com/multiformats/multihash/tree/master/tests/sharness).
22 |
23 | ## Table of Contents
24 |
25 | * [Install](#install)
26 | * [Usage](#usage)
27 | * [Supported hash algorithms](#supported-hash-algorithms)
28 | * [Maintainers](#maintainers)
29 | * [Contribute](#contribute)
30 | * [License](#license)
31 |
32 | ## Install
33 |
34 | PM> Install-Package Multiformats.Hash
35 |
36 | ---
37 |
38 | dotnet add package Multiformats.Hash
39 |
40 | ## Usage
41 |
42 | ```csharp
43 | // decode a multihash formatted byte array
44 | Multihash mh = Multihash.Decode(bytes);
45 |
46 | // decode a multihash formatted string
47 | Multihash mh = Multihash.Parse(str);
48 | bool ok = Multihash.TryParse(str, out mh);
49 |
50 | // encode a digest to multiformat byte array
51 | byte[] bytes = Multihash.Encode(digest, HashType.SHA1);
52 | byte[] bytes = Multihash.Encode(digest);
53 |
54 | // calculate digest
55 | Multihash mh = Multihash.Sum(bytes);
56 |
57 | // verify
58 | bool isValid = mh.Verify(bytes);
59 | ```
60 |
61 | ## Supported hash algorithms
62 |
63 | * ID
64 | * MD4
65 | * MD5
66 | * SHA1
67 | * SHA2_256
68 | * SHA2_512
69 | * SHA3_224
70 | * SHA3_256
71 | * SHA3_384
72 | * SHA3_512
73 | * SHAKE_128
74 | * SHAKE_256
75 | * KECCAK_224
76 | * KECCAK_256
77 | * KECCAK_384
78 | * KECCAK_512
79 | * BLAKE2B-(bits) (8-512)
80 | * BLAKE2S-(bits) (8-256)
81 | * DBL_SHA2_256
82 | * MURMUR3_32/128
83 | * SKEIN256-(bits) (8-256)
84 | * SKEIN512-(bits) (8-512)
85 | * SKEIN1024-(bits) (8-1024)
86 |
87 | ## Maintainers
88 |
89 | Captain: [@tabrath](https://github.com/tabrath).
90 |
91 | ## Contribute
92 |
93 | Contributions welcome. Please check out [the issues](https://github.com/multiformats/cs-multihash/issues).
94 |
95 | Check out our [contributing document](https://github.com/multiformats/multiformats/blob/master/contributing.md) for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
96 |
97 | Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
98 |
99 | ## License
100 |
101 | [MIT](LICENSE) © 2017-2018 Trond Bråthen
102 |
--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
1 | environment:
2 | PKG_VERSION: 1.5.0
3 | VERSION_SUFFIX: ""
4 | version: ${PKG_VERSION}-{build}
5 | configuration: Release
6 | platform: x64
7 | image: Visual Studio 2017
8 |
9 | skip_commits:
10 | message: /chore/
11 | files:
12 | - '**\*.md'
13 | - LICENSE
14 |
15 | skip_branch_with_pr: true
16 |
17 | branches:
18 | only:
19 | - master
20 |
21 | matrix:
22 | fast_finish: true
23 |
24 | init:
25 | - git config --global core.autocrlf input
26 | - ps: $env:BUILD_VERSION = "$env:PKG_VERSION-$env:APPVEYOR_BUILD_NUMBER"
27 | - ps: |
28 | if ($env:APPVEYOR_REPO_BRANCH -eq "master")
29 | {
30 | $env:VERSION_SUFFIX = ""
31 | $env:NUGET_VERSION = "$env:PKG_VERSION"
32 | }
33 | else
34 | {
35 | $env:VERSION_SUFFIX = "beta$env:APPVEYOR_BUILD_NUMBER"
36 | $env:NUGET_VERSION = "$env:PKG_VERSION-$env:VERSION_SUFFIX"
37 | }
38 | - ps: Update-AppveyorBuild -Version $env:BUILD_VERSION
39 | - ps: Write-Host "Build version $env:BUILD_VERSION, NuGet version $env:NUGET_VERSION, Version suffix $env:VERSION_SUFFIX"
40 |
41 | build_script:
42 | - ps: |
43 | if ($env:APPVEYOR_REPO_BRANCH -eq "master")
44 | {
45 | dotnet build "src\Multiformats.Hash" -c $env:CONFIGURATION
46 | }
47 | else
48 | {
49 | dotnet build "src\Multiformats.Hash" -c $env:CONFIGURATION --version-suffix $env:VERSION_SUFFIX
50 | }
51 |
52 | test: off
53 |
54 | test_script:
55 | - dotnet test -c %CONFIGURATION% -f netcoreapp2.0 /p:CollectCoverage=true "%APPVEYOR_BUILD_FOLDER%\test\Multiformats.Hash.Tests"
56 |
57 | on_success:
58 | - choco install codecov
59 | - codecov -f "%APPVEYOR_BUILD_FOLDER%\test\Multiformats.Hash.Tests\coverage.opencover.xml"
60 |
61 | artifacts:
62 | - path: '**\*.nupkg'
63 | name: nupkg
64 | - path: '**\*.snupkg'
65 | name: snupkg
66 |
67 | cache:
68 | - '%USERPROFILE%\.nuget\packages -> **\*.csproj'
69 | - '%LocalAppData%\NuGet\Cache'
70 |
71 | nuget:
72 | account_feed: true
73 |
74 | deploy:
75 | - provider: NuGet
76 | api_key:
77 | secure: WcDqU36pLPvA+s5D4N0VEsi7AZGewvf4croE/D3rh3F+iqiztq9w5gHbrhgoTNS9
78 | on:
79 | branch: master
80 | appveyor_repo_tag: true
81 | - provider: GitHub
82 | description: 'Release description'
83 | auth_token:
84 | secure: nsZHZ5nFBFP4fZoVUEeWeZKx7LUASVqCZ+JblTox+02RfTAOlANdFWeCqOwhu7pk
85 | artifact: /.*\.nupkg/ # upload all NuGet packages to release assets
86 | draft: false
87 | prerelease: false
88 | on:
89 | branch: master # release from master branch only
90 | appveyor_repo_tag: true
91 |
--------------------------------------------------------------------------------
/build.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | mono=${MONO:=0}
4 | dotnet=${DOTNET:=0}
5 |
6 | test_name=Multiformats.Hash.Tests
7 | test_project=./test/$test_name/$test_name.csproj
8 | cli_name=Multiformats.Hash.CLI
9 | cli_project=./src/$cli_name/$cli_name.csproj
10 |
11 | case "$1" in
12 | dotnet)
13 | dotnet=1
14 | mono=0
15 | ;;
16 | mono)
17 | mono=1
18 | dotnet=0
19 | ;;
20 | esac
21 |
22 | echo "* settings: mono=$mono, dotnet=$dotnet"
23 |
24 | set -e
25 |
26 | if [ $dotnet -eq 1 ]; then
27 | echo "* building and testing dotnet"
28 |
29 | if [ "$TRAVIS_OS_NAME" == "osx" ]; then
30 | ulimit -n 1024
31 | dotnet restore $test_project --disable-parallel --runtime osx-x64
32 | dotnet restore $cli_project --disable-parallel --runtime osx-x64
33 | else
34 | dotnet restore $test_project --runtime ubuntu-x64
35 | dotnet restore $cli_project --runtime ubuntu-x64
36 | fi
37 |
38 | dotnet test $test_project --configuration Release --framework netcoreapp2.0 --no-restore --blame
39 | dotnet build $cli_project --configuration Release --framework netcoreapp2.0 --no-restore
40 | fi
41 |
42 | if [ $mono -eq 1 ]; then
43 | echo "* building and testing mono"
44 | export FrameworkPathOverride=$(dirname $(which mono))/../lib/mono/4.5/
45 | msbuild $test_project /property:Configuration=Release,TargetFramework=net461,Platform=x64 /restore:true
46 | mono $HOME/.nuget/packages/xunit.runner.console/*/tools/net452/xunit.console.exe ./test/$test_name/bin/x64/Release/net461/$test_name.dll
47 |
48 | msbuild $cli_project /property:Configuration=Release,TargetFramework=net461,Platform=x64 /restore:true
49 | fi
50 |
--------------------------------------------------------------------------------
/multihash:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | mono=${MONO:=0}
4 | dotnet=${DOTNET:=0}
5 |
6 | case "$1" in
7 | dotnet)
8 | dotnet=1
9 | mono=0
10 | ;;
11 | mono)
12 | mono=1
13 | dotnet=0
14 | ;;
15 | esac
16 |
17 | if [ $dotnet -eq 1 ]; then
18 | dotnet run --configuration Release --framework netcoreapp2.0 --no-build --no-restore --project ${TRAVIS_BUILD_DIR}/src/Multiformats.Hash.CLI/Multiformats.Hash.CLI.csproj -- $@
19 | fi
20 |
21 | if [ $mono -eq 1 ]; then
22 | mono ${TRAVIS_BUILD_DIR}/src/Multiformats.Hash.CLI/bin/x64/Release/net461/Multiformats.Hash.CLI.exe $@
23 | fi
24 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash.Benchmarks/Multiformats.Hash.Benchmarks.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | netcoreapp2.0;net461
5 | win10-x64;osx-x64;ubuntu-x64
6 | $(PackageTargetFallback);netstandard;portable-net461+win8
7 | AnyCPU
8 | Exe
9 | $(NoWarn);NU1605
10 |
11 |
12 |
13 | true
14 | full
15 | false
16 | $(DefineConstants);DEBUG
17 |
18 |
19 | pdbonly
20 | true
21 | $(DefineConstants)
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash.Benchmarks/Program.cs:
--------------------------------------------------------------------------------
1 | using BenchmarkDotNet.Running;
2 |
3 | namespace Multiformats.Hash.Benchmarks
4 | {
5 | class Program
6 | {
7 | static void Main(string[] args) => new BenchmarkSwitcher(new[] {typeof(SumBenchmarks)}).Run(args);
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash.Benchmarks/SumBenchmarks.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using BenchmarkDotNet.Attributes;
3 | using Multiformats.Hash.Algorithms;
4 |
5 | namespace Multiformats.Hash.Benchmarks
6 | {
7 | [RyuJitX64Job]
8 | public class SumBenchmarks
9 | {
10 | private byte[] _bytes;
11 |
12 | [IterationSetup]
13 | public void Setup()
14 | {
15 | _bytes = new byte[64];
16 | new Random(Environment.TickCount).NextBytes(_bytes);
17 | }
18 |
19 | public Multihash Sum(int length = -1) where TAlgorithm : MultihashAlgorithm => Multihash.Sum(_bytes, length);
20 |
21 | [Benchmark]
22 | public Multihash Sum_ID() => Sum(64);
23 |
24 | [Benchmark]
25 | public Multihash Sum_SHA1() => Sum();
26 |
27 | [Benchmark]
28 | public Multihash Sum_SHA2_256() => Sum();
29 | [Benchmark]
30 | public Multihash Sum_DBL_SHA2_256() => Sum();
31 | [Benchmark]
32 | public Multihash Sum_SHA2_512() => Sum();
33 | [Benchmark]
34 | public Multihash Sum_SHA3_224() => Sum();
35 | [Benchmark]
36 | public Multihash Sum_SHA3_256() => Sum();
37 | [Benchmark]
38 | public Multihash Sum_SHA3_384() => Sum();
39 | [Benchmark]
40 | public Multihash Sum_SHA3_512() => Sum();
41 |
42 | [Benchmark]
43 | public Multihash Sum_KECCAK_224() => Sum();
44 | [Benchmark]
45 | public Multihash Sum_KECCAK_256() => Sum();
46 | [Benchmark]
47 | public Multihash Sum_KECCAK_384() => Sum();
48 | [Benchmark]
49 | public Multihash Sum_KECCAK_512() => Sum();
50 |
51 | [Benchmark]
52 | public Multihash Sum_SHAKE_128() => Sum();
53 | [Benchmark]
54 | public Multihash Sum_SHAKE_256() => Sum();
55 |
56 | [Benchmark]
57 | public Multihash Sum_BLAKE2B() => Sum();
58 | [Benchmark]
59 | public Multihash Sum_BLAKE2S() => Sum();
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash.CLI/Multiformats.Hash.CLI.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | netcoreapp2.0;net461
5 | win10-x64;osx-x64;ubuntu-x64
6 | x64
7 | Exe
8 | $(NoWarn);NU1605
9 |
10 |
11 |
12 | true
13 | full
14 | false
15 | $(DefineConstants);DEBUG
16 |
17 |
18 | pdbonly
19 | true
20 | $(DefineConstants)
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash.CLI/Program.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.IO;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Multiformats.Base;
6 |
7 | #pragma warning disable CS0675
8 |
9 | namespace Multiformats.Hash.CLI
10 | {
11 | class Program
12 | {
13 | public class Options
14 | {
15 | public HashType Algorithm { get; set; } = HashType.SHA2_256;
16 | public string Checksum { get; set; } = string.Empty;
17 | public MultibaseEncoding Encoding { get; set; } = MultibaseEncoding.Base58Btc;
18 | public int Length { get; set; } = -1;
19 | public bool Quiet { get; set; } = false;
20 | public Stream Source { get; set; } = null;
21 |
22 | public override string ToString() => $" Algorithm: {Algorithm}\n Checksum: {Checksum}\n Encoding: {Encoding}\n Length: {Length}\n Quiet: {Quiet}\n Source: {Source != null}";
23 | }
24 |
25 | static void Main(string[] args)
26 | {
27 | if (args.Length == 0)
28 | DisplayHelp();
29 |
30 | var options = ParseOptions(args);
31 |
32 | #if DEBUG
33 | Console.WriteLine($"Options:\n{options}");
34 | #endif
35 |
36 | if (options.Source == null)
37 | DisplayError("No source");
38 |
39 | Process(options);
40 | }
41 |
42 | private static void Process(Options options)
43 | {
44 | using (options.Source)
45 | {
46 | byte[] data = null;
47 | using (var mem = new MemoryStream())
48 | {
49 | options.Source.CopyTo(mem);
50 |
51 | data = mem.ToArray();
52 | }
53 |
54 | var mh = Multihash.Sum(options.Algorithm, data, options.Length);
55 |
56 | if (string.IsNullOrEmpty(options.Checksum))
57 | {
58 | Console.WriteLine(mh.ToString(options.Encoding));
59 | Environment.Exit(0);
60 | }
61 |
62 | var checksum = Multibase.DecodeRaw(options.Encoding, options.Checksum);
63 | if (!checksum.SequenceEqual(mh.Digest))
64 | {
65 | if (!options.Quiet)
66 | Console.WriteLine($"Digest mismatch, got: {Multibase.EncodeRaw(options.Encoding, mh.Digest)}, wanted: {Multibase.EncodeRaw(options.Encoding, checksum)}");
67 |
68 | Environment.Exit(1);
69 | }
70 |
71 | if (!options.Quiet)
72 | Console.WriteLine("Checksum match");
73 | }
74 | }
75 |
76 | private static Options ParseOptions(string[] args)
77 | {
78 | var options = new Options();
79 |
80 | var i = 0;
81 | while (i < args.Length)
82 | {
83 | if (args[i] == "-h" || args[i] == "--help")
84 | DisplayHelp();
85 |
86 | if (args[i] == "-v" || args[i] == "--version")
87 | DisplayVersion();
88 |
89 | if (args[i].StartsWith("-a") || args[i].StartsWith("--algorithm"))
90 | {
91 | string algo;
92 | if (args[i].Contains("="))
93 | {
94 | algo = args[i++].Split('=').Last();
95 | }
96 | else
97 | {
98 | if (++i >= args.Length)
99 | DisplayError("No algorithm specified");
100 |
101 | algo = args[i++];
102 | }
103 |
104 | var code = Hash.Multihash.GetCode(algo);
105 | if (!code.HasValue)
106 | DisplayError($"Unknown algorithm: {algo}");
107 |
108 | options.Algorithm = code.Value;
109 | continue;
110 | }
111 |
112 | if (args[i].StartsWith("-c") || args[i].StartsWith("--check"))
113 | {
114 | if (args[i].Contains("="))
115 | {
116 | options.Checksum = args[i++].Split('=').Last();
117 | }
118 | else
119 | {
120 | if (++i >= args.Length)
121 | DisplayError("No checksum specified");
122 |
123 | options.Checksum = args[i++];
124 | }
125 | continue;
126 | }
127 |
128 | if (args[i].StartsWith("-e") || args[i].StartsWith("--encoding"))
129 | {
130 | if (args[i].Contains("="))
131 | {
132 | options.Encoding = ParseEncoding(args[i++].Split('=').Last());
133 | }
134 | else
135 | {
136 | if (++i >= args.Length)
137 | DisplayError("No encoding specified");
138 |
139 | options.Encoding = ParseEncoding(args[i++]);
140 | }
141 | continue;
142 | }
143 |
144 | if (args[i].StartsWith("-l") || args[i].StartsWith("--length"))
145 | {
146 | string raw;
147 | if (args[i].Contains("="))
148 | {
149 | raw = args[i++].Split('=').Last();
150 | }
151 | else
152 | {
153 | if (++i >= args.Length)
154 | DisplayError("No length specified");
155 |
156 | raw = args[i++];
157 | }
158 |
159 | int length = -1;
160 | if (!int.TryParse(raw, out length))
161 | DisplayError("Invalid length specified");
162 |
163 | options.Length = length;
164 | continue;
165 | }
166 |
167 | if (args[i].StartsWith("-q") || args[i].StartsWith("--quiet"))
168 | {
169 | if (args[i].Contains("="))
170 | {
171 | var raw = args[i++].Split('=').Last();
172 | options.Quiet = !bool.TryParse(raw, out var value) || value;
173 | }
174 | else
175 | {
176 | i++;
177 | options.Quiet = true;
178 | }
179 | continue;
180 | }
181 |
182 | if (args[i] == "-")
183 | {
184 | i++;
185 | options.Source = Console.OpenStandardInput();
186 | continue;
187 | }
188 |
189 | if (!File.Exists(args[i]))
190 | {
191 | DisplayError($"File does not exists: {args[i]}");
192 | }
193 |
194 | options.Source = new FileStream(args[i], FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan); //File.OpenRead(args[i]);
195 | break;
196 | }
197 |
198 | return options;
199 | }
200 |
201 | private static void DisplayVersion()
202 | {
203 | var libversion = typeof(Multihash).GetTypeInfo().Assembly.GetCustomAttribute();
204 | var cliversion = typeof(Program).GetTypeInfo().Assembly.GetCustomAttribute();
205 |
206 | Console.WriteLine($"v{cliversion.Version} (library v{libversion.Version})");
207 | Environment.Exit(0);
208 | }
209 |
210 | private static MultibaseEncoding ParseEncoding(string s)
211 | {
212 | switch (s.ToLower().Trim())
213 | {
214 | case "base2": return MultibaseEncoding.Base2;
215 | case "base8": return MultibaseEncoding.Base8;
216 | case "hex": case "base16": return MultibaseEncoding.Base16Lower;
217 | case "base32": return MultibaseEncoding.Base32Lower;
218 | case "base58": return MultibaseEncoding.Base58Btc;
219 | case "base64": return MultibaseEncoding.Base64;
220 | default:
221 | DisplayError($"Unknown or unsupported encoding: {s}");
222 | return default(MultibaseEncoding);
223 | }
224 | }
225 |
226 | private static void DisplayError(string error)
227 | {
228 | Console.WriteLine($"Error: {error}");
229 | Environment.Exit(1);
230 | }
231 |
232 | private static void DisplayHelp()
233 | {
234 | Console.WriteLine("usage: multihash [options] [FILE]");
235 | Console.WriteLine("Print or check multihash checksums.");
236 | Console.WriteLine("With no FILE, or when FILE is -, read standard input.");
237 | Console.WriteLine();
238 | Console.WriteLine("Options:");
239 | Console.WriteLine(" -a, --algorithm string use specified algorithm (default: sha2-256)");
240 | Console.WriteLine(" -c, --check string check checksum matches");
241 | Console.WriteLine(" -e, --encoding string use specified encoding (default: base58)");
242 | Console.WriteLine(" -l, --length int checksum length in bits (truncate, default -1)");
243 | Console.WriteLine(" -q, --quiet quiet output (no newline on checksum, no error text)");
244 | Console.WriteLine(" -v, --version display version");
245 | Console.WriteLine(" -h, --help show help (this)");
246 |
247 | Environment.Exit(1);
248 | }
249 | }
250 | }
251 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/BLAKE2B.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class BLAKE2B : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected BLAKE2B(int bits)
13 | : base(GetHashType(bits), GetName(bits), bits / 8)
14 | {
15 | _factory = () => new Blake2bDigest(null, bits / 8, null, null);
16 | }
17 |
18 | private static HashType GetHashType(int bytes) => (HashType)Enum.Parse(typeof(HashType), $"BLAKE2B_{bytes}");
19 | private static string GetName(int bytes) => $"blake2b-{bytes}";
20 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
21 | }
22 |
23 | [Export(typeof(IMultihashAlgorithm))]
24 | [MultihashAlgorithmExport(HashType.BLAKE2B_8, "blake2b-8", 8)]
25 | public class BLAKE2B_8 : BLAKE2B { public BLAKE2B_8() : base(8) { } }
26 |
27 | [Export(typeof(IMultihashAlgorithm))]
28 | [MultihashAlgorithmExport(HashType.BLAKE2B_16, "blake2b-16", 16)]
29 | public class BLAKE2B_16 : BLAKE2B { public BLAKE2B_16() : base(16) { } }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.BLAKE2B_24, "blake2b-24", 24)]
33 | public class BLAKE2B_24 : BLAKE2B { public BLAKE2B_24() : base(24) { } }
34 |
35 | [Export(typeof(IMultihashAlgorithm))]
36 | [MultihashAlgorithmExport(HashType.BLAKE2B_32, "blake2b-32", 32)]
37 | public class BLAKE2B_32 : BLAKE2B { public BLAKE2B_32() : base(32) { } }
38 |
39 | [Export(typeof(IMultihashAlgorithm))]
40 | [MultihashAlgorithmExport(HashType.BLAKE2B_40, "blake2b-40", 40)]
41 | public class BLAKE2B_40 : BLAKE2B { public BLAKE2B_40() : base(40) { } }
42 |
43 | [Export(typeof(IMultihashAlgorithm))]
44 | [MultihashAlgorithmExport(HashType.BLAKE2B_48, "blake2b-48", 48)]
45 | public class BLAKE2B_48 : BLAKE2B { public BLAKE2B_48() : base(48) { } }
46 |
47 | [Export(typeof(IMultihashAlgorithm))]
48 | [MultihashAlgorithmExport(HashType.BLAKE2B_56, "blake2b-56", 56)]
49 | public class BLAKE2B_56 : BLAKE2B { public BLAKE2B_56() : base(56) { } }
50 |
51 | [Export(typeof(IMultihashAlgorithm))]
52 | [MultihashAlgorithmExport(HashType.BLAKE2B_64, "blake2b-64", 64)]
53 | public class BLAKE2B_64 : BLAKE2B { public BLAKE2B_64() : base(64) { } }
54 |
55 | [Export(typeof(IMultihashAlgorithm))]
56 | [MultihashAlgorithmExport(HashType.BLAKE2B_72, "blake2b-72", 72)]
57 | public class BLAKE2B_72 : BLAKE2B { public BLAKE2B_72() : base(72) { } }
58 |
59 | [Export(typeof(IMultihashAlgorithm))]
60 | [MultihashAlgorithmExport(HashType.BLAKE2B_80, "blake2b-80", 80)]
61 | public class BLAKE2B_80 : BLAKE2B { public BLAKE2B_80() : base(80) { } }
62 |
63 | [Export(typeof(IMultihashAlgorithm))]
64 | [MultihashAlgorithmExport(HashType.BLAKE2B_88, "blake2b-88", 88)]
65 | public class BLAKE2B_88 : BLAKE2B { public BLAKE2B_88() : base(88) { } }
66 |
67 | [Export(typeof(IMultihashAlgorithm))]
68 | [MultihashAlgorithmExport(HashType.BLAKE2B_96, "blake2b-96", 96)]
69 | public class BLAKE2B_96 : BLAKE2B { public BLAKE2B_96() : base(96) { } }
70 |
71 | [Export(typeof(IMultihashAlgorithm))]
72 | [MultihashAlgorithmExport(HashType.BLAKE2B_104, "blake2b-104", 104)]
73 | public class BLAKE2B_104 : BLAKE2B { public BLAKE2B_104() : base(104) { } }
74 |
75 | [Export(typeof(IMultihashAlgorithm))]
76 | [MultihashAlgorithmExport(HashType.BLAKE2B_112, "blake2b-112", 112)]
77 | public class BLAKE2B_112 : BLAKE2B { public BLAKE2B_112() : base(112) { } }
78 |
79 | [Export(typeof(IMultihashAlgorithm))]
80 | [MultihashAlgorithmExport(HashType.BLAKE2B_120, "blake2b-120", 120)]
81 | public class BLAKE2B_120 : BLAKE2B { public BLAKE2B_120() : base(120) { } }
82 |
83 | [Export(typeof(IMultihashAlgorithm))]
84 | [MultihashAlgorithmExport(HashType.BLAKE2B_128, "blake2b-128", 128)]
85 | public class BLAKE2B_128 : BLAKE2B { public BLAKE2B_128() : base(128) { } }
86 |
87 | [Export(typeof(IMultihashAlgorithm))]
88 | [MultihashAlgorithmExport(HashType.BLAKE2B_136, "blake2b-136", 136)]
89 | public class BLAKE2B_136 : BLAKE2B { public BLAKE2B_136() : base(136) { } }
90 |
91 | [Export(typeof(IMultihashAlgorithm))]
92 | [MultihashAlgorithmExport(HashType.BLAKE2B_144, "blake2b-144", 144)]
93 | public class BLAKE2B_144 : BLAKE2B { public BLAKE2B_144() : base(144) { } }
94 |
95 | [Export(typeof(IMultihashAlgorithm))]
96 | [MultihashAlgorithmExport(HashType.BLAKE2B_152, "blake2b-152", 152)]
97 | public class BLAKE2B_152 : BLAKE2B { public BLAKE2B_152() : base(152) { } }
98 |
99 | [Export(typeof(IMultihashAlgorithm))]
100 | [MultihashAlgorithmExport(HashType.BLAKE2B_160, "blake2b-160", 160)]
101 | public class BLAKE2B_160 : BLAKE2B { public BLAKE2B_160() : base(160) { } }
102 |
103 | [Export(typeof(IMultihashAlgorithm))]
104 | [MultihashAlgorithmExport(HashType.BLAKE2B_168, "blake2b-168", 168)]
105 | public class BLAKE2B_168 : BLAKE2B { public BLAKE2B_168() : base(168) { } }
106 |
107 | [Export(typeof(IMultihashAlgorithm))]
108 | [MultihashAlgorithmExport(HashType.BLAKE2B_176, "blake2b-176", 176)]
109 | public class BLAKE2B_176 : BLAKE2B { public BLAKE2B_176() : base(176) { } }
110 |
111 | [Export(typeof(IMultihashAlgorithm))]
112 | [MultihashAlgorithmExport(HashType.BLAKE2B_184, "blake2b-184", 184)]
113 | public class BLAKE2B_184 : BLAKE2B { public BLAKE2B_184() : base(184) { } }
114 |
115 | [Export(typeof(IMultihashAlgorithm))]
116 | [MultihashAlgorithmExport(HashType.BLAKE2B_192, "blake2b-192", 192)]
117 | public class BLAKE2B_192 : BLAKE2B { public BLAKE2B_192() : base(192) { } }
118 |
119 | [Export(typeof(IMultihashAlgorithm))]
120 | [MultihashAlgorithmExport(HashType.BLAKE2B_200, "blake2b-200", 200)]
121 | public class BLAKE2B_200 : BLAKE2B { public BLAKE2B_200() : base(200) { } }
122 |
123 | [Export(typeof(IMultihashAlgorithm))]
124 | [MultihashAlgorithmExport(HashType.BLAKE2B_208, "blake2b-208", 208)]
125 | public class BLAKE2B_208 : BLAKE2B { public BLAKE2B_208() : base(208) { } }
126 |
127 | [Export(typeof(IMultihashAlgorithm))]
128 | [MultihashAlgorithmExport(HashType.BLAKE2B_216, "blake2b-216", 216)]
129 | public class BLAKE2B_216 : BLAKE2B { public BLAKE2B_216() : base(216) { } }
130 |
131 | [Export(typeof(IMultihashAlgorithm))]
132 | [MultihashAlgorithmExport(HashType.BLAKE2B_224, "blake2b-224", 224)]
133 | public class BLAKE2B_224 : BLAKE2B { public BLAKE2B_224() : base(224) { } }
134 |
135 | [Export(typeof(IMultihashAlgorithm))]
136 | [MultihashAlgorithmExport(HashType.BLAKE2B_232, "blake2b-232", 232)]
137 | public class BLAKE2B_232 : BLAKE2B { public BLAKE2B_232() : base(232) { } }
138 |
139 | [Export(typeof(IMultihashAlgorithm))]
140 | [MultihashAlgorithmExport(HashType.BLAKE2B_240, "blake2b-240", 240)]
141 | public class BLAKE2B_240 : BLAKE2B { public BLAKE2B_240() : base(240) { } }
142 |
143 | [Export(typeof(IMultihashAlgorithm))]
144 | [MultihashAlgorithmExport(HashType.BLAKE2B_248, "blake2b-248", 248)]
145 | public class BLAKE2B_248 : BLAKE2B { public BLAKE2B_248() : base(248) { } }
146 |
147 | [Export(typeof(IMultihashAlgorithm))]
148 | [MultihashAlgorithmExport(HashType.BLAKE2B_256, "blake2b-256", 256)]
149 | public class BLAKE2B_256 : BLAKE2B { public BLAKE2B_256() : base(256) { } }
150 |
151 | [Export(typeof(IMultihashAlgorithm))]
152 | [MultihashAlgorithmExport(HashType.BLAKE2B_264, "blake2b-264", 264)]
153 | public class BLAKE2B_264 : BLAKE2B { public BLAKE2B_264() : base(264) { } }
154 |
155 | [Export(typeof(IMultihashAlgorithm))]
156 | [MultihashAlgorithmExport(HashType.BLAKE2B_272, "blake2b-272", 272)]
157 | public class BLAKE2B_272 : BLAKE2B { public BLAKE2B_272() : base(272) { } }
158 |
159 | [Export(typeof(IMultihashAlgorithm))]
160 | [MultihashAlgorithmExport(HashType.BLAKE2B_280, "blake2b-280", 280)]
161 | public class BLAKE2B_280 : BLAKE2B { public BLAKE2B_280() : base(280) { } }
162 |
163 | [Export(typeof(IMultihashAlgorithm))]
164 | [MultihashAlgorithmExport(HashType.BLAKE2B_288, "blake2b-288", 288)]
165 | public class BLAKE2B_288 : BLAKE2B { public BLAKE2B_288() : base(288) { } }
166 |
167 | [Export(typeof(IMultihashAlgorithm))]
168 | [MultihashAlgorithmExport(HashType.BLAKE2B_296, "blake2b-296", 296)]
169 | public class BLAKE2B_296 : BLAKE2B { public BLAKE2B_296() : base(296) { } }
170 |
171 | [Export(typeof(IMultihashAlgorithm))]
172 | [MultihashAlgorithmExport(HashType.BLAKE2B_304, "blake2b-304", 304)]
173 | public class BLAKE2B_304 : BLAKE2B { public BLAKE2B_304() : base(304) { } }
174 |
175 | [Export(typeof(IMultihashAlgorithm))]
176 | [MultihashAlgorithmExport(HashType.BLAKE2B_312, "blake2b-312", 312)]
177 | public class BLAKE2B_312 : BLAKE2B { public BLAKE2B_312() : base(312) { } }
178 |
179 | [Export(typeof(IMultihashAlgorithm))]
180 | [MultihashAlgorithmExport(HashType.BLAKE2B_320, "blake2b-320", 320)]
181 | public class BLAKE2B_320 : BLAKE2B { public BLAKE2B_320() : base(320) { } }
182 |
183 | [Export(typeof(IMultihashAlgorithm))]
184 | [MultihashAlgorithmExport(HashType.BLAKE2B_328, "blake2b-328", 328)]
185 | public class BLAKE2B_328 : BLAKE2B { public BLAKE2B_328() : base(328) { } }
186 |
187 | [Export(typeof(IMultihashAlgorithm))]
188 | [MultihashAlgorithmExport(HashType.BLAKE2B_336, "blake2b-336", 336)]
189 | public class BLAKE2B_336 : BLAKE2B { public BLAKE2B_336() : base(336) { } }
190 |
191 | [Export(typeof(IMultihashAlgorithm))]
192 | [MultihashAlgorithmExport(HashType.BLAKE2B_344, "blake2b-344", 344)]
193 | public class BLAKE2B_344 : BLAKE2B { public BLAKE2B_344() : base(344) { } }
194 |
195 | [Export(typeof(IMultihashAlgorithm))]
196 | [MultihashAlgorithmExport(HashType.BLAKE2B_352, "blake2b-352", 352)]
197 | public class BLAKE2B_352 : BLAKE2B { public BLAKE2B_352() : base(352) { } }
198 |
199 | [Export(typeof(IMultihashAlgorithm))]
200 | [MultihashAlgorithmExport(HashType.BLAKE2B_360, "blake2b-360", 360)]
201 | public class BLAKE2B_360 : BLAKE2B { public BLAKE2B_360() : base(360) { } }
202 |
203 | [Export(typeof(IMultihashAlgorithm))]
204 | [MultihashAlgorithmExport(HashType.BLAKE2B_368, "blake2b-368", 368)]
205 | public class BLAKE2B_368 : BLAKE2B { public BLAKE2B_368() : base(368) { } }
206 |
207 | [Export(typeof(IMultihashAlgorithm))]
208 | [MultihashAlgorithmExport(HashType.BLAKE2B_376, "blake2b-376", 376)]
209 | public class BLAKE2B_376 : BLAKE2B { public BLAKE2B_376() : base(376) { } }
210 |
211 | [Export(typeof(IMultihashAlgorithm))]
212 | [MultihashAlgorithmExport(HashType.BLAKE2B_384, "blake2b-384", 384)]
213 | public class BLAKE2B_384 : BLAKE2B { public BLAKE2B_384() : base(384) { } }
214 |
215 | [Export(typeof(IMultihashAlgorithm))]
216 | [MultihashAlgorithmExport(HashType.BLAKE2B_392, "blake2b-392", 392)]
217 | public class BLAKE2B_392 : BLAKE2B { public BLAKE2B_392() : base(392) { } }
218 |
219 | [Export(typeof(IMultihashAlgorithm))]
220 | [MultihashAlgorithmExport(HashType.BLAKE2B_400, "blake2b-400", 400)]
221 | public class BLAKE2B_400 : BLAKE2B { public BLAKE2B_400() : base(400) { } }
222 |
223 | [Export(typeof(IMultihashAlgorithm))]
224 | [MultihashAlgorithmExport(HashType.BLAKE2B_408, "blake2b-408", 408)]
225 | public class BLAKE2B_408 : BLAKE2B { public BLAKE2B_408() : base(408) { } }
226 |
227 | [Export(typeof(IMultihashAlgorithm))]
228 | [MultihashAlgorithmExport(HashType.BLAKE2B_416, "blake2b-416", 416)]
229 | public class BLAKE2B_416 : BLAKE2B { public BLAKE2B_416() : base(416) { } }
230 |
231 | [Export(typeof(IMultihashAlgorithm))]
232 | [MultihashAlgorithmExport(HashType.BLAKE2B_424, "blake2b-424", 424)]
233 | public class BLAKE2B_424 : BLAKE2B { public BLAKE2B_424() : base(424) { } }
234 |
235 | [Export(typeof(IMultihashAlgorithm))]
236 | [MultihashAlgorithmExport(HashType.BLAKE2B_432, "blake2b-432", 432)]
237 | public class BLAKE2B_432 : BLAKE2B { public BLAKE2B_432() : base(432) { } }
238 |
239 | [Export(typeof(IMultihashAlgorithm))]
240 | [MultihashAlgorithmExport(HashType.BLAKE2B_440, "blake2b-440", 440)]
241 | public class BLAKE2B_440 : BLAKE2B { public BLAKE2B_440() : base(440) { } }
242 |
243 | [Export(typeof(IMultihashAlgorithm))]
244 | [MultihashAlgorithmExport(HashType.BLAKE2B_448, "blake2b-448", 448)]
245 | public class BLAKE2B_448 : BLAKE2B { public BLAKE2B_448() : base(448) { } }
246 |
247 | [Export(typeof(IMultihashAlgorithm))]
248 | [MultihashAlgorithmExport(HashType.BLAKE2B_456, "blake2b-456", 456)]
249 | public class BLAKE2B_456 : BLAKE2B { public BLAKE2B_456() : base(456) { } }
250 |
251 | [Export(typeof(IMultihashAlgorithm))]
252 | [MultihashAlgorithmExport(HashType.BLAKE2B_464, "blake2b-464", 464)]
253 | public class BLAKE2B_464 : BLAKE2B { public BLAKE2B_464() : base(464) { } }
254 |
255 | [Export(typeof(IMultihashAlgorithm))]
256 | [MultihashAlgorithmExport(HashType.BLAKE2B_472, "blake2b-472", 472)]
257 | public class BLAKE2B_472 : BLAKE2B { public BLAKE2B_472() : base(472) { } }
258 |
259 | [Export(typeof(IMultihashAlgorithm))]
260 | [MultihashAlgorithmExport(HashType.BLAKE2B_480, "blake2b-480", 480)]
261 | public class BLAKE2B_480 : BLAKE2B { public BLAKE2B_480() : base(480) { } }
262 |
263 | [Export(typeof(IMultihashAlgorithm))]
264 | [MultihashAlgorithmExport(HashType.BLAKE2B_488, "blake2b-488", 488)]
265 | public class BLAKE2B_488 : BLAKE2B { public BLAKE2B_488() : base(488) { } }
266 |
267 | [Export(typeof(IMultihashAlgorithm))]
268 | [MultihashAlgorithmExport(HashType.BLAKE2B_496, "blake2b-496", 496)]
269 | public class BLAKE2B_496 : BLAKE2B { public BLAKE2B_496() : base(496) { } }
270 |
271 | [Export(typeof(IMultihashAlgorithm))]
272 | [MultihashAlgorithmExport(HashType.BLAKE2B_504, "blake2b-504", 504)]
273 | public class BLAKE2B_504 : BLAKE2B { public BLAKE2B_504() : base(504) { } }
274 |
275 | [Export(typeof(IMultihashAlgorithm))]
276 | [MultihashAlgorithmExport(HashType.BLAKE2B_512, "blake2b-512", 512)]
277 | public class BLAKE2B_512 : BLAKE2B { public BLAKE2B_512() : base(512) { } }
278 | }
279 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/BLAKE2B.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class BLAKE2B : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected BLAKE2B(int bits)
19 | : base(GetHashType(bits), GetName(bits), bits / 8)
20 | {
21 | _factory = () => new Blake2bDigest(null, bits / 8, null, null);
22 | }
23 |
24 | private static HashType GetHashType(int bytes) => (HashType)Enum.Parse(typeof(HashType), $"BLAKE2B_{bytes}");
25 | private static string GetName(int bytes) => $"blake2b-{bytes}";
26 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
27 | }
28 | <#
29 | for (int i = 8; i <= 512; i += 8)
30 | {
31 | #>
32 |
33 | [Export(typeof(IMultihashAlgorithm))]
34 | [MultihashAlgorithmExport(HashType.BLAKE2B_<#= i #>, "blake2b-<#= i #>", <#= i #>)]
35 | public class BLAKE2B_<#= i #> : BLAKE2B { public BLAKE2B_<#= i #>() : base(<#= i #>) { } }
36 | <#
37 | }
38 | #>
39 | }
40 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/BLAKE2S.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class BLAKE2S : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected BLAKE2S(int bits)
13 | : base(GetHashType(bits), GetName(bits), bits / 8)
14 | {
15 | _factory = () => new Blake2sDigest(null, bits / 8, null, null);
16 | }
17 |
18 | private static HashType GetHashType(int bytes) => (HashType)Enum.Parse(typeof(HashType), $"BLAKE2S_{bytes}");
19 | private static string GetName(int bytes) => $"blake2s-{bytes}";
20 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
21 | }
22 |
23 | [Export(typeof(IMultihashAlgorithm))]
24 | [MultihashAlgorithmExport(HashType.BLAKE2S_8, "blake2s-8", 8)]
25 | public class BLAKE2S_8 : BLAKE2S { public BLAKE2S_8() : base(8) { } }
26 |
27 | [Export(typeof(IMultihashAlgorithm))]
28 | [MultihashAlgorithmExport(HashType.BLAKE2S_16, "blake2s-16", 16)]
29 | public class BLAKE2S_16 : BLAKE2S { public BLAKE2S_16() : base(16) { } }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.BLAKE2S_24, "blake2s-24", 24)]
33 | public class BLAKE2S_24 : BLAKE2S { public BLAKE2S_24() : base(24) { } }
34 |
35 | [Export(typeof(IMultihashAlgorithm))]
36 | [MultihashAlgorithmExport(HashType.BLAKE2S_32, "blake2s-32", 32)]
37 | public class BLAKE2S_32 : BLAKE2S { public BLAKE2S_32() : base(32) { } }
38 |
39 | [Export(typeof(IMultihashAlgorithm))]
40 | [MultihashAlgorithmExport(HashType.BLAKE2S_40, "blake2s-40", 40)]
41 | public class BLAKE2S_40 : BLAKE2S { public BLAKE2S_40() : base(40) { } }
42 |
43 | [Export(typeof(IMultihashAlgorithm))]
44 | [MultihashAlgorithmExport(HashType.BLAKE2S_48, "blake2s-48", 48)]
45 | public class BLAKE2S_48 : BLAKE2S { public BLAKE2S_48() : base(48) { } }
46 |
47 | [Export(typeof(IMultihashAlgorithm))]
48 | [MultihashAlgorithmExport(HashType.BLAKE2S_56, "blake2s-56", 56)]
49 | public class BLAKE2S_56 : BLAKE2S { public BLAKE2S_56() : base(56) { } }
50 |
51 | [Export(typeof(IMultihashAlgorithm))]
52 | [MultihashAlgorithmExport(HashType.BLAKE2S_64, "blake2s-64", 64)]
53 | public class BLAKE2S_64 : BLAKE2S { public BLAKE2S_64() : base(64) { } }
54 |
55 | [Export(typeof(IMultihashAlgorithm))]
56 | [MultihashAlgorithmExport(HashType.BLAKE2S_72, "blake2s-72", 72)]
57 | public class BLAKE2S_72 : BLAKE2S { public BLAKE2S_72() : base(72) { } }
58 |
59 | [Export(typeof(IMultihashAlgorithm))]
60 | [MultihashAlgorithmExport(HashType.BLAKE2S_80, "blake2s-80", 80)]
61 | public class BLAKE2S_80 : BLAKE2S { public BLAKE2S_80() : base(80) { } }
62 |
63 | [Export(typeof(IMultihashAlgorithm))]
64 | [MultihashAlgorithmExport(HashType.BLAKE2S_88, "blake2s-88", 88)]
65 | public class BLAKE2S_88 : BLAKE2S { public BLAKE2S_88() : base(88) { } }
66 |
67 | [Export(typeof(IMultihashAlgorithm))]
68 | [MultihashAlgorithmExport(HashType.BLAKE2S_96, "blake2s-96", 96)]
69 | public class BLAKE2S_96 : BLAKE2S { public BLAKE2S_96() : base(96) { } }
70 |
71 | [Export(typeof(IMultihashAlgorithm))]
72 | [MultihashAlgorithmExport(HashType.BLAKE2S_104, "blake2s-104", 104)]
73 | public class BLAKE2S_104 : BLAKE2S { public BLAKE2S_104() : base(104) { } }
74 |
75 | [Export(typeof(IMultihashAlgorithm))]
76 | [MultihashAlgorithmExport(HashType.BLAKE2S_112, "blake2s-112", 112)]
77 | public class BLAKE2S_112 : BLAKE2S { public BLAKE2S_112() : base(112) { } }
78 |
79 | [Export(typeof(IMultihashAlgorithm))]
80 | [MultihashAlgorithmExport(HashType.BLAKE2S_120, "blake2s-120", 120)]
81 | public class BLAKE2S_120 : BLAKE2S { public BLAKE2S_120() : base(120) { } }
82 |
83 | [Export(typeof(IMultihashAlgorithm))]
84 | [MultihashAlgorithmExport(HashType.BLAKE2S_128, "blake2s-128", 128)]
85 | public class BLAKE2S_128 : BLAKE2S { public BLAKE2S_128() : base(128) { } }
86 |
87 | [Export(typeof(IMultihashAlgorithm))]
88 | [MultihashAlgorithmExport(HashType.BLAKE2S_136, "blake2s-136", 136)]
89 | public class BLAKE2S_136 : BLAKE2S { public BLAKE2S_136() : base(136) { } }
90 |
91 | [Export(typeof(IMultihashAlgorithm))]
92 | [MultihashAlgorithmExport(HashType.BLAKE2S_144, "blake2s-144", 144)]
93 | public class BLAKE2S_144 : BLAKE2S { public BLAKE2S_144() : base(144) { } }
94 |
95 | [Export(typeof(IMultihashAlgorithm))]
96 | [MultihashAlgorithmExport(HashType.BLAKE2S_152, "blake2s-152", 152)]
97 | public class BLAKE2S_152 : BLAKE2S { public BLAKE2S_152() : base(152) { } }
98 |
99 | [Export(typeof(IMultihashAlgorithm))]
100 | [MultihashAlgorithmExport(HashType.BLAKE2S_160, "blake2s-160", 160)]
101 | public class BLAKE2S_160 : BLAKE2S { public BLAKE2S_160() : base(160) { } }
102 |
103 | [Export(typeof(IMultihashAlgorithm))]
104 | [MultihashAlgorithmExport(HashType.BLAKE2S_168, "blake2s-168", 168)]
105 | public class BLAKE2S_168 : BLAKE2S { public BLAKE2S_168() : base(168) { } }
106 |
107 | [Export(typeof(IMultihashAlgorithm))]
108 | [MultihashAlgorithmExport(HashType.BLAKE2S_176, "blake2s-176", 176)]
109 | public class BLAKE2S_176 : BLAKE2S { public BLAKE2S_176() : base(176) { } }
110 |
111 | [Export(typeof(IMultihashAlgorithm))]
112 | [MultihashAlgorithmExport(HashType.BLAKE2S_184, "blake2s-184", 184)]
113 | public class BLAKE2S_184 : BLAKE2S { public BLAKE2S_184() : base(184) { } }
114 |
115 | [Export(typeof(IMultihashAlgorithm))]
116 | [MultihashAlgorithmExport(HashType.BLAKE2S_192, "blake2s-192", 192)]
117 | public class BLAKE2S_192 : BLAKE2S { public BLAKE2S_192() : base(192) { } }
118 |
119 | [Export(typeof(IMultihashAlgorithm))]
120 | [MultihashAlgorithmExport(HashType.BLAKE2S_200, "blake2s-200", 200)]
121 | public class BLAKE2S_200 : BLAKE2S { public BLAKE2S_200() : base(200) { } }
122 |
123 | [Export(typeof(IMultihashAlgorithm))]
124 | [MultihashAlgorithmExport(HashType.BLAKE2S_208, "blake2s-208", 208)]
125 | public class BLAKE2S_208 : BLAKE2S { public BLAKE2S_208() : base(208) { } }
126 |
127 | [Export(typeof(IMultihashAlgorithm))]
128 | [MultihashAlgorithmExport(HashType.BLAKE2S_216, "blake2s-216", 216)]
129 | public class BLAKE2S_216 : BLAKE2S { public BLAKE2S_216() : base(216) { } }
130 |
131 | [Export(typeof(IMultihashAlgorithm))]
132 | [MultihashAlgorithmExport(HashType.BLAKE2S_224, "blake2s-224", 224)]
133 | public class BLAKE2S_224 : BLAKE2S { public BLAKE2S_224() : base(224) { } }
134 |
135 | [Export(typeof(IMultihashAlgorithm))]
136 | [MultihashAlgorithmExport(HashType.BLAKE2S_232, "blake2s-232", 232)]
137 | public class BLAKE2S_232 : BLAKE2S { public BLAKE2S_232() : base(232) { } }
138 |
139 | [Export(typeof(IMultihashAlgorithm))]
140 | [MultihashAlgorithmExport(HashType.BLAKE2S_240, "blake2s-240", 240)]
141 | public class BLAKE2S_240 : BLAKE2S { public BLAKE2S_240() : base(240) { } }
142 |
143 | [Export(typeof(IMultihashAlgorithm))]
144 | [MultihashAlgorithmExport(HashType.BLAKE2S_248, "blake2s-248", 248)]
145 | public class BLAKE2S_248 : BLAKE2S { public BLAKE2S_248() : base(248) { } }
146 |
147 | [Export(typeof(IMultihashAlgorithm))]
148 | [MultihashAlgorithmExport(HashType.BLAKE2S_256, "blake2s-256", 256)]
149 | public class BLAKE2S_256 : BLAKE2S { public BLAKE2S_256() : base(256) { } }
150 | }
151 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/BLAKE2S.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class BLAKE2S : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected BLAKE2S(int bits)
19 | : base(GetHashType(bits), GetName(bits), bits / 8)
20 | {
21 | _factory = () => new Blake2sDigest(null, bits / 8, null, null);
22 | }
23 |
24 | private static HashType GetHashType(int bytes) => (HashType)Enum.Parse(typeof(HashType), $"BLAKE2S_{bytes}");
25 | private static string GetName(int bytes) => $"blake2s-{bytes}";
26 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
27 | }
28 | <#
29 | for (int i = 8; i <= 256; i += 8)
30 | {
31 | #>
32 |
33 | [Export(typeof(IMultihashAlgorithm))]
34 | [MultihashAlgorithmExport(HashType.BLAKE2S_<#= i #>, "blake2s-<#= i #>", <#= i #>)]
35 | public class BLAKE2S_<#= i #> : BLAKE2S { public BLAKE2S_<#= i #>() : base(<#= i #>) { } }
36 | <#
37 | }
38 | #>
39 | }
40 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/DBL_SHA2_256.cs:
--------------------------------------------------------------------------------
1 | using System.Composition;
2 |
3 | namespace Multiformats.Hash.Algorithms
4 | {
5 | [Export(typeof(IMultihashAlgorithm))]
6 | [MultihashAlgorithmExport(HashType.DBL_SHA2_256, "dbl-sha2-256", 32)]
7 | public class DBL_SHA2_256 : MultihashAlgorithm
8 | {
9 | private readonly System.Security.Cryptography.HashAlgorithm _algo;
10 |
11 | public DBL_SHA2_256()
12 | : base(HashType.DBL_SHA2_256, "dbl-sha2-256", 32)
13 | {
14 | _algo = System.Security.Cryptography.SHA256.Create();
15 | }
16 |
17 | public override byte[] ComputeHash(byte[] data, int length = -1) => _algo.ComputeHash(_algo.ComputeHash(data));
18 | }
19 | }
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/Extensions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Text;
5 | using System.Threading.Tasks;
6 | using Org.BouncyCastle.Crypto;
7 |
8 | namespace Multiformats.Hash.Algorithms
9 | {
10 | internal static class Extensions
11 | {
12 | public static byte[] ComputeHash(this IDigest digest, byte[] data)
13 | {
14 | digest.Reset();
15 | digest.BlockUpdate(data, 0, data.Length);
16 | var hash = new byte[digest.GetByteLength()];
17 | digest.DoFinal(hash, 0);
18 | return hash;
19 | }
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/ID.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 |
4 | namespace Multiformats.Hash.Algorithms
5 | {
6 | [Export(typeof(IMultihashAlgorithm))]
7 | [MultihashAlgorithmExport(HashType.ID, "id", 32)]
8 | public class ID : MultihashAlgorithm
9 | {
10 | public ID()
11 | : base(HashType.ID, "id", 32)
12 | {
13 | }
14 |
15 | public override byte[] ComputeHash(byte[] data, int length = -1)
16 | {
17 | if (length >= 0 && length != data.Length)
18 | throw new Exception($"The length of the identity hash ({length}) must be equal to the length of the data ({data.Length})");
19 |
20 | return data;
21 | }
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/KECCAK.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class KECCAK : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected KECCAK(HashType code, string name, int defaultLength, Func factory)
13 | : base(code, name, defaultLength)
14 | {
15 | _factory = factory;
16 | }
17 |
18 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
19 | }
20 |
21 | [Export(typeof(IMultihashAlgorithm))]
22 | [MultihashAlgorithmExport(HashType.KECCAK_224, "keccak-224", 28)]
23 | public class KECCAK_224 : KECCAK
24 | {
25 | public KECCAK_224()
26 | : base(HashType.KECCAK_224, "keccak-224", 28, () => new KeccakDigest(224))
27 | {
28 | }
29 | }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.KECCAK_256, "keccak-256", 32)]
33 | public class KECCAK_256 : KECCAK
34 | {
35 | public KECCAK_256()
36 | : base(HashType.KECCAK_256, "keccak-256", 32, () => new KeccakDigest(256))
37 | {
38 | }
39 | }
40 |
41 | [Export(typeof(IMultihashAlgorithm))]
42 | [MultihashAlgorithmExport(HashType.KECCAK_384, "keccak-384", 48)]
43 | public class KECCAK_384 : KECCAK
44 | {
45 | public KECCAK_384()
46 | : base(HashType.KECCAK_384, "keccak-384", 48, () => new KeccakDigest(384))
47 | {
48 | }
49 | }
50 |
51 | [Export(typeof(IMultihashAlgorithm))]
52 | [MultihashAlgorithmExport(HashType.KECCAK_512, "keccak-512", 64)]
53 | public class KECCAK_512 : KECCAK
54 | {
55 | public KECCAK_512()
56 | : base(HashType.KECCAK_512, "keccak-512", 64, () => new KeccakDigest(512))
57 | {
58 | }
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/KECCAK.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class KECCAK : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected KECCAK(HashType code, string name, int defaultLength, Func factory)
19 | : base(code, name, defaultLength)
20 | {
21 | _factory = factory;
22 | }
23 |
24 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
25 | }
26 | <#
27 | var bits = new int[] { 224, 256, 384, 512 };
28 | foreach (var bit in bits)
29 | {
30 | #>
31 |
32 | [Export(typeof(IMultihashAlgorithm))]
33 | [MultihashAlgorithmExport(HashType.KECCAK_<#= bit #>, "keccak-<#= bit #>", <#= bit / 8 #>)]
34 | public class KECCAK_<#= bit #> : KECCAK
35 | {
36 | public KECCAK_<#= bit #>()
37 | : base(HashType.KECCAK_<#= bit #>, "keccak-<#= bit #>", <#= bit / 8 #>, () => new KeccakDigest(<#= bit #>))
38 | {
39 | }
40 | }
41 | <#
42 | }
43 | #>
44 | }
45 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/MD4.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | [Export(typeof(IMultihashAlgorithm))]
9 | [MultihashAlgorithmExport(HashType.MD4, "md4", 16)]
10 | public class MD4 : MultihashAlgorithm
11 | {
12 | private readonly Func _factory;
13 |
14 | public MD4()
15 | : base(HashType.MD4, "md4", 16)
16 | {
17 | _factory = () => new MD4Digest();
18 | }
19 |
20 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/MD5.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | [Export(typeof(IMultihashAlgorithm))]
9 | [MultihashAlgorithmExport(HashType.MD5, "md5", 16)]
10 | public class MD5 : MultihashAlgorithm
11 | {
12 | private readonly Func _factory;
13 |
14 | public MD5()
15 | : base(HashType.MD5, "md5", 16)
16 | {
17 | _factory = () => new MD5Digest();
18 | }
19 |
20 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
21 | }
22 | }
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/MURMUR3.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using System.Linq;
4 | using System.Security.Cryptography;
5 | using Murmur;
6 |
7 | namespace Multiformats.Hash.Algorithms
8 | {
9 | [Export(typeof(IMultihashAlgorithm))]
10 | [MultihashAlgorithmExport(HashType.MURMUR3_32, "murmur3-32", 4)]
11 | public class MURMUR3_32 : MultihashAlgorithm
12 | {
13 | private readonly Func _factory;
14 |
15 | public MURMUR3_32()
16 | : base(HashType.MURMUR3_32, "murmur3-32", 4)
17 | {
18 | _factory = () => MurmurHash.Create32(managed: false);
19 | }
20 |
21 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
22 | }
23 |
24 | [Export(typeof(IMultihashAlgorithm))]
25 | [MultihashAlgorithmExport(HashType.MURMUR3_128, "murmur3-128", 16)]
26 | public class MURMUR3_128 : MultihashAlgorithm
27 | {
28 | private readonly Func _factory;
29 |
30 | public MURMUR3_128()
31 | : base(HashType.MURMUR3_128, "murmur3-128", 16)
32 | {
33 | _factory = () => MurmurHash.Create128(managed: false, preference: AlgorithmPreference.X64);
34 | }
35 |
36 | public override byte[] ComputeHash(byte[] data, int length = -1)
37 | {
38 | var value = _factory().ComputeHash(data);
39 |
40 | Array.Reverse(value, 0, 8);
41 | Array.Reverse(value, 8, 8);
42 |
43 | return value;
44 | }
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/MultihashAlgorithm.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using System.Threading.Tasks;
4 |
5 | namespace Multiformats.Hash.Algorithms
6 | {
7 | public interface IMultihashAlgorithm
8 | {
9 | HashType Code { get; }
10 | string Name { get; }
11 | int DefaultLength { get; }
12 | byte[] ComputeHash(byte[] data, int length = -1);
13 | Task ComputeHashAsync(byte[] data, int length = -1);
14 | }
15 |
16 | public abstract class MultihashAlgorithm : IMultihashAlgorithm
17 | {
18 | private static readonly Lazy _random = new Lazy(() => new Random(Environment.TickCount));
19 | private readonly Lazy _hashCode;
20 |
21 | public HashType Code { get; }
22 | public string Name { get; }
23 | public int DefaultLength { get; }
24 |
25 | protected MultihashAlgorithm(HashType code, string name, int defaultLength)
26 | {
27 | Code = code;
28 | Name = name;
29 | DefaultLength = defaultLength;
30 |
31 | _hashCode = new Lazy(() => (int)Code ^ Name.GetHashCode() ^ DefaultLength ^ _random.Value.Next());
32 | }
33 |
34 | public abstract byte[] ComputeHash(byte[] data, int length = -1);
35 | public virtual Task ComputeHashAsync(byte[] data, int length = -1) => Task.Factory.StartNew(() => ComputeHash(data, length));
36 |
37 | public override int GetHashCode() => _hashCode.Value;
38 | }
39 |
40 | public interface IMultihashAlgorithmMetadata
41 | {
42 | HashType Code { get; }
43 | string Name { get; }
44 | int DefaultLength { get; }
45 | }
46 |
47 | public class MultihashAlgorithmMetadata : IMultihashAlgorithmMetadata
48 | {
49 | public HashType Code { get; set; }
50 | public string Name { get; set; }
51 | public int DefaultLength { get; set; }
52 | }
53 |
54 | [AttributeUsage(AttributeTargets.Class)]
55 | [MetadataAttribute]
56 | public class MultihashAlgorithmExportAttribute : Attribute, IMultihashAlgorithmMetadata
57 | {
58 | public HashType Code { get; }
59 | public string Name { get; }
60 | public int DefaultLength { get; }
61 |
62 | public MultihashAlgorithmExportAttribute(HashType code, string name, int defaultLength)
63 | {
64 | Code = code;
65 | Name = name;
66 | DefaultLength = defaultLength;
67 | }
68 | }
69 | }
70 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/Registry.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Concurrent;
3 | using System.Collections.Generic;
4 | using System.Composition;
5 | using System.Composition.Hosting;
6 | using System.Linq;
7 | using System.Reflection;
8 | using System.Threading.Tasks;
9 |
10 | namespace Multiformats.Hash.Algorithms
11 | {
12 | internal class Registry : IDisposable
13 | {
14 | private readonly CompositionHost _container;
15 | private readonly IEnumerable> _algorithms;
16 | private readonly ConcurrentDictionary> _cache;
17 |
18 | public HashType[] SupportedHashTypes => _algorithms.Select(a => a.Metadata.Code).OrderBy(x => x.ToString()).ToArray();
19 |
20 | public Registry()
21 | {
22 | _container = new ContainerConfiguration()
23 | .WithAssembly(typeof(Registry).GetTypeInfo().Assembly)
24 | .CreateContainer();
25 |
26 | _algorithms = _container.GetExports>();
27 | _cache = new ConcurrentDictionary>();
28 | }
29 |
30 | public IMultihashAlgorithm Get(HashType type)
31 | {
32 | var algo = _algorithms.SingleOrDefault(a => a.Metadata.Code.Equals(type));
33 | if (algo == null)
34 | throw new NotSupportedException($"{type} is not supported.");
35 |
36 | var export = algo.CreateExport();
37 |
38 | _cache.TryAdd(algo.GetHashCode(), export);
39 |
40 | return export.Value;
41 | }
42 |
43 | public IMultihashAlgorithm Get()
44 | where TAlgorithm : IMultihashAlgorithm
45 | {
46 | var code = GetHashType();
47 | if (!code.HasValue || !Enum.IsDefined(typeof(HashType), code.Value))
48 | throw new NotSupportedException($"{typeof(TAlgorithm)} is not supported.");
49 |
50 | return Get(code.Value);
51 | }
52 |
53 | public void Return(IMultihashAlgorithm algo)
54 | {
55 | if (_cache.TryRemove(algo.GetHashCode(), out var export))
56 | export?.Dispose();
57 | }
58 |
59 | public T Use(HashType code, Func func)
60 | {
61 | var algorithm = Get(code);
62 | try
63 | {
64 | return func(algorithm);
65 | }
66 | finally
67 | {
68 | Return(algorithm);
69 | }
70 | }
71 |
72 | public async Task UseAsync(HashType code, Func> func)
73 | {
74 | var algorithm = Get(code);
75 | try
76 | {
77 | return await func(algorithm).ConfigureAwait(false);
78 | }
79 | finally
80 | {
81 | Return(algorithm);
82 | }
83 | }
84 |
85 | public TResult Use(Func func)
86 | where TAlgorithm : IMultihashAlgorithm
87 | {
88 | var algorithm = Get();
89 | try
90 | {
91 | return func(algorithm);
92 | }
93 | finally
94 | {
95 | Return(algorithm);
96 | }
97 | }
98 |
99 | public async Task UseAsync(Func> func)
100 | where TAlgorithm : IMultihashAlgorithm
101 | {
102 | var algorithm = Get();
103 | try
104 | {
105 | return await func(algorithm);
106 | }
107 | finally
108 | {
109 | Return(algorithm);
110 | }
111 | }
112 |
113 | public static HashType? GetHashType()
114 | where TAlgorithm : IMultihashAlgorithm
115 | {
116 | return typeof(TAlgorithm).GetTypeInfo().GetCustomAttribute()?.Code;
117 | }
118 |
119 | public void Dispose()
120 | {
121 | _container?.Dispose();
122 | }
123 | }
124 | }
125 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHA1.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | [Export(typeof(IMultihashAlgorithm))]
9 | [MultihashAlgorithmExport(HashType.SHA1, "sha1", 20)]
10 | public class SHA1 : MultihashAlgorithm
11 | {
12 | private readonly Func _factory;
13 |
14 | public SHA1()
15 | : base(HashType.SHA1, "sha1", 20)
16 | {
17 | _factory = () => new Sha1Digest();
18 | }
19 |
20 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
21 | }
22 | }
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHA2.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class SHA2 : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected SHA2(HashType code, string name, int defaultLength, Func factory)
13 | : base(code, name, defaultLength)
14 | {
15 | _factory = factory;
16 | }
17 |
18 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
19 | }
20 |
21 | [Export(typeof(IMultihashAlgorithm))]
22 | [MultihashAlgorithmExport(HashType.SHA2_256, "sha2-256", 32)]
23 | public class SHA2_256 : SHA2
24 | {
25 | public SHA2_256()
26 | : base(HashType.SHA2_256, "sha2-256", 32, () => new Sha256Digest())
27 | {
28 | }
29 | }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.SHA2_512, "sha2-512", 64)]
33 | public class SHA2_512 : SHA2
34 | {
35 | public SHA2_512()
36 | : base(HashType.SHA2_512, "sha2-512", 64, () => new Sha512Digest())
37 | {
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHA2.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class SHA2 : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected SHA2(HashType code, string name, int defaultLength, Func factory)
19 | : base(code, name, defaultLength)
20 | {
21 | _factory = factory;
22 | }
23 |
24 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
25 | }
26 | <#
27 | var bits = new int[] { 256, 512 };
28 | foreach (var bit in bits)
29 | {
30 | #>
31 |
32 | [Export(typeof(IMultihashAlgorithm))]
33 | [MultihashAlgorithmExport(HashType.SHA2_<#= bit #>, "sha2-<#= bit #>", <#= bit / 8 #>)]
34 | public class SHA2_<#= bit #> : SHA2
35 | {
36 | public SHA2_<#= bit #>()
37 | : base(HashType.SHA2_<#= bit #>, "sha2-<#= bit #>", <#= bit / 8 #>, () => new Sha<#= bit #>Digest())
38 | {
39 | }
40 | }
41 | <#
42 | }
43 | #>
44 | }
45 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHA3.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class SHA3 : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected SHA3(HashType code, string name, int defaultLength, Func factory)
13 | : base(code, name, defaultLength)
14 | {
15 | _factory = factory;
16 | }
17 |
18 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
19 | }
20 |
21 | [Export(typeof(IMultihashAlgorithm))]
22 | [MultihashAlgorithmExport(HashType.SHA3_224, "sha3-224", 28)]
23 | public class SHA3_224 : SHA3
24 | {
25 | public SHA3_224()
26 | : base(HashType.SHA3_224, "sha3-224", 28, () => new Sha3Digest(224))
27 | {
28 | }
29 | }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.SHA3_256, "sha3-256", 32)]
33 | public class SHA3_256 : SHA3
34 | {
35 | public SHA3_256()
36 | : base(HashType.SHA3_256, "sha3-256", 32, () => new Sha3Digest(256))
37 | {
38 | }
39 | }
40 |
41 | [Export(typeof(IMultihashAlgorithm))]
42 | [MultihashAlgorithmExport(HashType.SHA3_384, "sha3-384", 48)]
43 | public class SHA3_384 : SHA3
44 | {
45 | public SHA3_384()
46 | : base(HashType.SHA3_384, "sha3-384", 48, () => new Sha3Digest(384))
47 | {
48 | }
49 | }
50 |
51 | [Export(typeof(IMultihashAlgorithm))]
52 | [MultihashAlgorithmExport(HashType.SHA3_512, "sha3-512", 64)]
53 | public class SHA3_512 : SHA3
54 | {
55 | public SHA3_512()
56 | : base(HashType.SHA3_512, "sha3-512", 64, () => new Sha3Digest(512))
57 | {
58 | }
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHA3.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class SHA3 : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected SHA3(HashType code, string name, int defaultLength, Func factory)
19 | : base(code, name, defaultLength)
20 | {
21 | _factory = factory;
22 | }
23 |
24 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
25 | }
26 | <#
27 | var bits = new int[] { 224, 256, 384, 512 };
28 | foreach (var bit in bits)
29 | {
30 | #>
31 |
32 | [Export(typeof(IMultihashAlgorithm))]
33 | [MultihashAlgorithmExport(HashType.SHA3_<#= bit #>, "sha3-<#= bit #>", <#= bit / 8 #>)]
34 | public class SHA3_<#= bit #> : SHA3
35 | {
36 | public SHA3_<#= bit #>()
37 | : base(HashType.SHA3_<#= bit #>, "sha3-<#= bit #>", <#= bit / 8 #>, () => new Sha3Digest(<#= bit #>))
38 | {
39 | }
40 | }
41 | <#
42 | }
43 | #>
44 | }
45 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHAKE.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class SHAKE : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected SHAKE(HashType code, string name, int defaultLength, Func factory)
13 | : base(code, name, defaultLength)
14 | {
15 | _factory = factory;
16 | }
17 |
18 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
19 | }
20 |
21 | [Export(typeof(IMultihashAlgorithm))]
22 | [MultihashAlgorithmExport(HashType.SHAKE_128, "shake-128", 16)]
23 | public class SHAKE_128 : SHAKE
24 | {
25 | public SHAKE_128()
26 | : base(HashType.SHAKE_128, "shake-128", 16, () => new ShakeDigest(128))
27 | {
28 | }
29 | }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.SHAKE_256, "shake-256", 32)]
33 | public class SHAKE_256 : SHAKE
34 | {
35 | public SHAKE_256()
36 | : base(HashType.SHAKE_256, "shake-256", 32, () => new ShakeDigest(256))
37 | {
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SHAKE.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class SHAKE : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected SHAKE(HashType code, string name, int defaultLength, Func factory)
19 | : base(code, name, defaultLength)
20 | {
21 | _factory = factory;
22 | }
23 |
24 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
25 | }
26 | <#
27 | var bits = new int[] { 128, 256 };
28 | foreach (var bit in bits)
29 | {
30 | #>
31 |
32 | [Export(typeof(IMultihashAlgorithm))]
33 | [MultihashAlgorithmExport(HashType.SHAKE_<#= bit #>, "shake-<#= bit #>", <#= bit / 8 #>)]
34 | public class SHAKE_<#= bit #> : SHAKE
35 | {
36 | public SHAKE_<#= bit #>()
37 | : base(HashType.SHAKE_<#= bit #>, "shake-<#= bit #>", <#= bit / 8 #>, () => new ShakeDigest(<#= bit #>))
38 | {
39 | }
40 | }
41 | <#
42 | }
43 | #>
44 | }
45 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SKEIN.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Composition;
3 | using Org.BouncyCastle.Crypto;
4 | using Org.BouncyCastle.Crypto.Digests;
5 |
6 | namespace Multiformats.Hash.Algorithms
7 | {
8 | public abstract class SKEIN : MultihashAlgorithm
9 | {
10 | private readonly Func _factory;
11 |
12 | protected SKEIN(HashType code, string name, int defaultLength, Func factory)
13 | : base(code, name, defaultLength)
14 | {
15 | _factory = factory;
16 | }
17 |
18 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
19 | }
20 |
21 | [Export(typeof(IMultihashAlgorithm))]
22 | [MultihashAlgorithmExport(HashType.SKEIN256_8, "skein256-8", 8)]
23 | public class SKEIN256_8 : SKEIN
24 | {
25 | public SKEIN256_8()
26 | : base(HashType.SKEIN256_8, "skein256-8", 8, () => new SkeinDigest(256, 8))
27 | {
28 | }
29 | }
30 |
31 | [Export(typeof(IMultihashAlgorithm))]
32 | [MultihashAlgorithmExport(HashType.SKEIN256_16, "skein256-16", 16)]
33 | public class SKEIN256_16 : SKEIN
34 | {
35 | public SKEIN256_16()
36 | : base(HashType.SKEIN256_16, "skein256-16", 16, () => new SkeinDigest(256, 16))
37 | {
38 | }
39 | }
40 |
41 | [Export(typeof(IMultihashAlgorithm))]
42 | [MultihashAlgorithmExport(HashType.SKEIN256_24, "skein256-24", 24)]
43 | public class SKEIN256_24 : SKEIN
44 | {
45 | public SKEIN256_24()
46 | : base(HashType.SKEIN256_24, "skein256-24", 24, () => new SkeinDigest(256, 24))
47 | {
48 | }
49 | }
50 |
51 | [Export(typeof(IMultihashAlgorithm))]
52 | [MultihashAlgorithmExport(HashType.SKEIN256_32, "skein256-32", 32)]
53 | public class SKEIN256_32 : SKEIN
54 | {
55 | public SKEIN256_32()
56 | : base(HashType.SKEIN256_32, "skein256-32", 32, () => new SkeinDigest(256, 32))
57 | {
58 | }
59 | }
60 |
61 | [Export(typeof(IMultihashAlgorithm))]
62 | [MultihashAlgorithmExport(HashType.SKEIN256_40, "skein256-40", 40)]
63 | public class SKEIN256_40 : SKEIN
64 | {
65 | public SKEIN256_40()
66 | : base(HashType.SKEIN256_40, "skein256-40", 40, () => new SkeinDigest(256, 40))
67 | {
68 | }
69 | }
70 |
71 | [Export(typeof(IMultihashAlgorithm))]
72 | [MultihashAlgorithmExport(HashType.SKEIN256_48, "skein256-48", 48)]
73 | public class SKEIN256_48 : SKEIN
74 | {
75 | public SKEIN256_48()
76 | : base(HashType.SKEIN256_48, "skein256-48", 48, () => new SkeinDigest(256, 48))
77 | {
78 | }
79 | }
80 |
81 | [Export(typeof(IMultihashAlgorithm))]
82 | [MultihashAlgorithmExport(HashType.SKEIN256_56, "skein256-56", 56)]
83 | public class SKEIN256_56 : SKEIN
84 | {
85 | public SKEIN256_56()
86 | : base(HashType.SKEIN256_56, "skein256-56", 56, () => new SkeinDigest(256, 56))
87 | {
88 | }
89 | }
90 |
91 | [Export(typeof(IMultihashAlgorithm))]
92 | [MultihashAlgorithmExport(HashType.SKEIN256_64, "skein256-64", 64)]
93 | public class SKEIN256_64 : SKEIN
94 | {
95 | public SKEIN256_64()
96 | : base(HashType.SKEIN256_64, "skein256-64", 64, () => new SkeinDigest(256, 64))
97 | {
98 | }
99 | }
100 |
101 | [Export(typeof(IMultihashAlgorithm))]
102 | [MultihashAlgorithmExport(HashType.SKEIN256_72, "skein256-72", 72)]
103 | public class SKEIN256_72 : SKEIN
104 | {
105 | public SKEIN256_72()
106 | : base(HashType.SKEIN256_72, "skein256-72", 72, () => new SkeinDigest(256, 72))
107 | {
108 | }
109 | }
110 |
111 | [Export(typeof(IMultihashAlgorithm))]
112 | [MultihashAlgorithmExport(HashType.SKEIN256_80, "skein256-80", 80)]
113 | public class SKEIN256_80 : SKEIN
114 | {
115 | public SKEIN256_80()
116 | : base(HashType.SKEIN256_80, "skein256-80", 80, () => new SkeinDigest(256, 80))
117 | {
118 | }
119 | }
120 |
121 | [Export(typeof(IMultihashAlgorithm))]
122 | [MultihashAlgorithmExport(HashType.SKEIN256_88, "skein256-88", 88)]
123 | public class SKEIN256_88 : SKEIN
124 | {
125 | public SKEIN256_88()
126 | : base(HashType.SKEIN256_88, "skein256-88", 88, () => new SkeinDigest(256, 88))
127 | {
128 | }
129 | }
130 |
131 | [Export(typeof(IMultihashAlgorithm))]
132 | [MultihashAlgorithmExport(HashType.SKEIN256_96, "skein256-96", 96)]
133 | public class SKEIN256_96 : SKEIN
134 | {
135 | public SKEIN256_96()
136 | : base(HashType.SKEIN256_96, "skein256-96", 96, () => new SkeinDigest(256, 96))
137 | {
138 | }
139 | }
140 |
141 | [Export(typeof(IMultihashAlgorithm))]
142 | [MultihashAlgorithmExport(HashType.SKEIN256_104, "skein256-104", 104)]
143 | public class SKEIN256_104 : SKEIN
144 | {
145 | public SKEIN256_104()
146 | : base(HashType.SKEIN256_104, "skein256-104", 104, () => new SkeinDigest(256, 104))
147 | {
148 | }
149 | }
150 |
151 | [Export(typeof(IMultihashAlgorithm))]
152 | [MultihashAlgorithmExport(HashType.SKEIN256_112, "skein256-112", 112)]
153 | public class SKEIN256_112 : SKEIN
154 | {
155 | public SKEIN256_112()
156 | : base(HashType.SKEIN256_112, "skein256-112", 112, () => new SkeinDigest(256, 112))
157 | {
158 | }
159 | }
160 |
161 | [Export(typeof(IMultihashAlgorithm))]
162 | [MultihashAlgorithmExport(HashType.SKEIN256_120, "skein256-120", 120)]
163 | public class SKEIN256_120 : SKEIN
164 | {
165 | public SKEIN256_120()
166 | : base(HashType.SKEIN256_120, "skein256-120", 120, () => new SkeinDigest(256, 120))
167 | {
168 | }
169 | }
170 |
171 | [Export(typeof(IMultihashAlgorithm))]
172 | [MultihashAlgorithmExport(HashType.SKEIN256_128, "skein256-128", 128)]
173 | public class SKEIN256_128 : SKEIN
174 | {
175 | public SKEIN256_128()
176 | : base(HashType.SKEIN256_128, "skein256-128", 128, () => new SkeinDigest(256, 128))
177 | {
178 | }
179 | }
180 |
181 | [Export(typeof(IMultihashAlgorithm))]
182 | [MultihashAlgorithmExport(HashType.SKEIN256_136, "skein256-136", 136)]
183 | public class SKEIN256_136 : SKEIN
184 | {
185 | public SKEIN256_136()
186 | : base(HashType.SKEIN256_136, "skein256-136", 136, () => new SkeinDigest(256, 136))
187 | {
188 | }
189 | }
190 |
191 | [Export(typeof(IMultihashAlgorithm))]
192 | [MultihashAlgorithmExport(HashType.SKEIN256_144, "skein256-144", 144)]
193 | public class SKEIN256_144 : SKEIN
194 | {
195 | public SKEIN256_144()
196 | : base(HashType.SKEIN256_144, "skein256-144", 144, () => new SkeinDigest(256, 144))
197 | {
198 | }
199 | }
200 |
201 | [Export(typeof(IMultihashAlgorithm))]
202 | [MultihashAlgorithmExport(HashType.SKEIN256_152, "skein256-152", 152)]
203 | public class SKEIN256_152 : SKEIN
204 | {
205 | public SKEIN256_152()
206 | : base(HashType.SKEIN256_152, "skein256-152", 152, () => new SkeinDigest(256, 152))
207 | {
208 | }
209 | }
210 |
211 | [Export(typeof(IMultihashAlgorithm))]
212 | [MultihashAlgorithmExport(HashType.SKEIN256_160, "skein256-160", 160)]
213 | public class SKEIN256_160 : SKEIN
214 | {
215 | public SKEIN256_160()
216 | : base(HashType.SKEIN256_160, "skein256-160", 160, () => new SkeinDigest(256, 160))
217 | {
218 | }
219 | }
220 |
221 | [Export(typeof(IMultihashAlgorithm))]
222 | [MultihashAlgorithmExport(HashType.SKEIN256_168, "skein256-168", 168)]
223 | public class SKEIN256_168 : SKEIN
224 | {
225 | public SKEIN256_168()
226 | : base(HashType.SKEIN256_168, "skein256-168", 168, () => new SkeinDigest(256, 168))
227 | {
228 | }
229 | }
230 |
231 | [Export(typeof(IMultihashAlgorithm))]
232 | [MultihashAlgorithmExport(HashType.SKEIN256_176, "skein256-176", 176)]
233 | public class SKEIN256_176 : SKEIN
234 | {
235 | public SKEIN256_176()
236 | : base(HashType.SKEIN256_176, "skein256-176", 176, () => new SkeinDigest(256, 176))
237 | {
238 | }
239 | }
240 |
241 | [Export(typeof(IMultihashAlgorithm))]
242 | [MultihashAlgorithmExport(HashType.SKEIN256_184, "skein256-184", 184)]
243 | public class SKEIN256_184 : SKEIN
244 | {
245 | public SKEIN256_184()
246 | : base(HashType.SKEIN256_184, "skein256-184", 184, () => new SkeinDigest(256, 184))
247 | {
248 | }
249 | }
250 |
251 | [Export(typeof(IMultihashAlgorithm))]
252 | [MultihashAlgorithmExport(HashType.SKEIN256_192, "skein256-192", 192)]
253 | public class SKEIN256_192 : SKEIN
254 | {
255 | public SKEIN256_192()
256 | : base(HashType.SKEIN256_192, "skein256-192", 192, () => new SkeinDigest(256, 192))
257 | {
258 | }
259 | }
260 |
261 | [Export(typeof(IMultihashAlgorithm))]
262 | [MultihashAlgorithmExport(HashType.SKEIN256_200, "skein256-200", 200)]
263 | public class SKEIN256_200 : SKEIN
264 | {
265 | public SKEIN256_200()
266 | : base(HashType.SKEIN256_200, "skein256-200", 200, () => new SkeinDigest(256, 200))
267 | {
268 | }
269 | }
270 |
271 | [Export(typeof(IMultihashAlgorithm))]
272 | [MultihashAlgorithmExport(HashType.SKEIN256_208, "skein256-208", 208)]
273 | public class SKEIN256_208 : SKEIN
274 | {
275 | public SKEIN256_208()
276 | : base(HashType.SKEIN256_208, "skein256-208", 208, () => new SkeinDigest(256, 208))
277 | {
278 | }
279 | }
280 |
281 | [Export(typeof(IMultihashAlgorithm))]
282 | [MultihashAlgorithmExport(HashType.SKEIN256_216, "skein256-216", 216)]
283 | public class SKEIN256_216 : SKEIN
284 | {
285 | public SKEIN256_216()
286 | : base(HashType.SKEIN256_216, "skein256-216", 216, () => new SkeinDigest(256, 216))
287 | {
288 | }
289 | }
290 |
291 | [Export(typeof(IMultihashAlgorithm))]
292 | [MultihashAlgorithmExport(HashType.SKEIN256_224, "skein256-224", 224)]
293 | public class SKEIN256_224 : SKEIN
294 | {
295 | public SKEIN256_224()
296 | : base(HashType.SKEIN256_224, "skein256-224", 224, () => new SkeinDigest(256, 224))
297 | {
298 | }
299 | }
300 |
301 | [Export(typeof(IMultihashAlgorithm))]
302 | [MultihashAlgorithmExport(HashType.SKEIN256_232, "skein256-232", 232)]
303 | public class SKEIN256_232 : SKEIN
304 | {
305 | public SKEIN256_232()
306 | : base(HashType.SKEIN256_232, "skein256-232", 232, () => new SkeinDigest(256, 232))
307 | {
308 | }
309 | }
310 |
311 | [Export(typeof(IMultihashAlgorithm))]
312 | [MultihashAlgorithmExport(HashType.SKEIN256_240, "skein256-240", 240)]
313 | public class SKEIN256_240 : SKEIN
314 | {
315 | public SKEIN256_240()
316 | : base(HashType.SKEIN256_240, "skein256-240", 240, () => new SkeinDigest(256, 240))
317 | {
318 | }
319 | }
320 |
321 | [Export(typeof(IMultihashAlgorithm))]
322 | [MultihashAlgorithmExport(HashType.SKEIN256_248, "skein256-248", 248)]
323 | public class SKEIN256_248 : SKEIN
324 | {
325 | public SKEIN256_248()
326 | : base(HashType.SKEIN256_248, "skein256-248", 248, () => new SkeinDigest(256, 248))
327 | {
328 | }
329 | }
330 |
331 | [Export(typeof(IMultihashAlgorithm))]
332 | [MultihashAlgorithmExport(HashType.SKEIN256_256, "skein256-256", 256)]
333 | public class SKEIN256_256 : SKEIN
334 | {
335 | public SKEIN256_256()
336 | : base(HashType.SKEIN256_256, "skein256-256", 256, () => new SkeinDigest(256, 256))
337 | {
338 | }
339 | }
340 |
341 | [Export(typeof(IMultihashAlgorithm))]
342 | [MultihashAlgorithmExport(HashType.SKEIN512_8, "skein512-8", 8)]
343 | public class SKEIN512_8 : SKEIN
344 | {
345 | public SKEIN512_8()
346 | : base(HashType.SKEIN512_8, "skein512-8", 8, () => new SkeinDigest(512, 8))
347 | {
348 | }
349 | }
350 |
351 | [Export(typeof(IMultihashAlgorithm))]
352 | [MultihashAlgorithmExport(HashType.SKEIN512_16, "skein512-16", 16)]
353 | public class SKEIN512_16 : SKEIN
354 | {
355 | public SKEIN512_16()
356 | : base(HashType.SKEIN512_16, "skein512-16", 16, () => new SkeinDigest(512, 16))
357 | {
358 | }
359 | }
360 |
361 | [Export(typeof(IMultihashAlgorithm))]
362 | [MultihashAlgorithmExport(HashType.SKEIN512_24, "skein512-24", 24)]
363 | public class SKEIN512_24 : SKEIN
364 | {
365 | public SKEIN512_24()
366 | : base(HashType.SKEIN512_24, "skein512-24", 24, () => new SkeinDigest(512, 24))
367 | {
368 | }
369 | }
370 |
371 | [Export(typeof(IMultihashAlgorithm))]
372 | [MultihashAlgorithmExport(HashType.SKEIN512_32, "skein512-32", 32)]
373 | public class SKEIN512_32 : SKEIN
374 | {
375 | public SKEIN512_32()
376 | : base(HashType.SKEIN512_32, "skein512-32", 32, () => new SkeinDigest(512, 32))
377 | {
378 | }
379 | }
380 |
381 | [Export(typeof(IMultihashAlgorithm))]
382 | [MultihashAlgorithmExport(HashType.SKEIN512_40, "skein512-40", 40)]
383 | public class SKEIN512_40 : SKEIN
384 | {
385 | public SKEIN512_40()
386 | : base(HashType.SKEIN512_40, "skein512-40", 40, () => new SkeinDigest(512, 40))
387 | {
388 | }
389 | }
390 |
391 | [Export(typeof(IMultihashAlgorithm))]
392 | [MultihashAlgorithmExport(HashType.SKEIN512_48, "skein512-48", 48)]
393 | public class SKEIN512_48 : SKEIN
394 | {
395 | public SKEIN512_48()
396 | : base(HashType.SKEIN512_48, "skein512-48", 48, () => new SkeinDigest(512, 48))
397 | {
398 | }
399 | }
400 |
401 | [Export(typeof(IMultihashAlgorithm))]
402 | [MultihashAlgorithmExport(HashType.SKEIN512_56, "skein512-56", 56)]
403 | public class SKEIN512_56 : SKEIN
404 | {
405 | public SKEIN512_56()
406 | : base(HashType.SKEIN512_56, "skein512-56", 56, () => new SkeinDigest(512, 56))
407 | {
408 | }
409 | }
410 |
411 | [Export(typeof(IMultihashAlgorithm))]
412 | [MultihashAlgorithmExport(HashType.SKEIN512_64, "skein512-64", 64)]
413 | public class SKEIN512_64 : SKEIN
414 | {
415 | public SKEIN512_64()
416 | : base(HashType.SKEIN512_64, "skein512-64", 64, () => new SkeinDigest(512, 64))
417 | {
418 | }
419 | }
420 |
421 | [Export(typeof(IMultihashAlgorithm))]
422 | [MultihashAlgorithmExport(HashType.SKEIN512_72, "skein512-72", 72)]
423 | public class SKEIN512_72 : SKEIN
424 | {
425 | public SKEIN512_72()
426 | : base(HashType.SKEIN512_72, "skein512-72", 72, () => new SkeinDigest(512, 72))
427 | {
428 | }
429 | }
430 |
431 | [Export(typeof(IMultihashAlgorithm))]
432 | [MultihashAlgorithmExport(HashType.SKEIN512_80, "skein512-80", 80)]
433 | public class SKEIN512_80 : SKEIN
434 | {
435 | public SKEIN512_80()
436 | : base(HashType.SKEIN512_80, "skein512-80", 80, () => new SkeinDigest(512, 80))
437 | {
438 | }
439 | }
440 |
441 | [Export(typeof(IMultihashAlgorithm))]
442 | [MultihashAlgorithmExport(HashType.SKEIN512_88, "skein512-88", 88)]
443 | public class SKEIN512_88 : SKEIN
444 | {
445 | public SKEIN512_88()
446 | : base(HashType.SKEIN512_88, "skein512-88", 88, () => new SkeinDigest(512, 88))
447 | {
448 | }
449 | }
450 |
451 | [Export(typeof(IMultihashAlgorithm))]
452 | [MultihashAlgorithmExport(HashType.SKEIN512_96, "skein512-96", 96)]
453 | public class SKEIN512_96 : SKEIN
454 | {
455 | public SKEIN512_96()
456 | : base(HashType.SKEIN512_96, "skein512-96", 96, () => new SkeinDigest(512, 96))
457 | {
458 | }
459 | }
460 |
461 | [Export(typeof(IMultihashAlgorithm))]
462 | [MultihashAlgorithmExport(HashType.SKEIN512_104, "skein512-104", 104)]
463 | public class SKEIN512_104 : SKEIN
464 | {
465 | public SKEIN512_104()
466 | : base(HashType.SKEIN512_104, "skein512-104", 104, () => new SkeinDigest(512, 104))
467 | {
468 | }
469 | }
470 |
471 | [Export(typeof(IMultihashAlgorithm))]
472 | [MultihashAlgorithmExport(HashType.SKEIN512_112, "skein512-112", 112)]
473 | public class SKEIN512_112 : SKEIN
474 | {
475 | public SKEIN512_112()
476 | : base(HashType.SKEIN512_112, "skein512-112", 112, () => new SkeinDigest(512, 112))
477 | {
478 | }
479 | }
480 |
481 | [Export(typeof(IMultihashAlgorithm))]
482 | [MultihashAlgorithmExport(HashType.SKEIN512_120, "skein512-120", 120)]
483 | public class SKEIN512_120 : SKEIN
484 | {
485 | public SKEIN512_120()
486 | : base(HashType.SKEIN512_120, "skein512-120", 120, () => new SkeinDigest(512, 120))
487 | {
488 | }
489 | }
490 |
491 | [Export(typeof(IMultihashAlgorithm))]
492 | [MultihashAlgorithmExport(HashType.SKEIN512_128, "skein512-128", 128)]
493 | public class SKEIN512_128 : SKEIN
494 | {
495 | public SKEIN512_128()
496 | : base(HashType.SKEIN512_128, "skein512-128", 128, () => new SkeinDigest(512, 128))
497 | {
498 | }
499 | }
500 |
501 | [Export(typeof(IMultihashAlgorithm))]
502 | [MultihashAlgorithmExport(HashType.SKEIN512_136, "skein512-136", 136)]
503 | public class SKEIN512_136 : SKEIN
504 | {
505 | public SKEIN512_136()
506 | : base(HashType.SKEIN512_136, "skein512-136", 136, () => new SkeinDigest(512, 136))
507 | {
508 | }
509 | }
510 |
511 | [Export(typeof(IMultihashAlgorithm))]
512 | [MultihashAlgorithmExport(HashType.SKEIN512_144, "skein512-144", 144)]
513 | public class SKEIN512_144 : SKEIN
514 | {
515 | public SKEIN512_144()
516 | : base(HashType.SKEIN512_144, "skein512-144", 144, () => new SkeinDigest(512, 144))
517 | {
518 | }
519 | }
520 |
521 | [Export(typeof(IMultihashAlgorithm))]
522 | [MultihashAlgorithmExport(HashType.SKEIN512_152, "skein512-152", 152)]
523 | public class SKEIN512_152 : SKEIN
524 | {
525 | public SKEIN512_152()
526 | : base(HashType.SKEIN512_152, "skein512-152", 152, () => new SkeinDigest(512, 152))
527 | {
528 | }
529 | }
530 |
531 | [Export(typeof(IMultihashAlgorithm))]
532 | [MultihashAlgorithmExport(HashType.SKEIN512_160, "skein512-160", 160)]
533 | public class SKEIN512_160 : SKEIN
534 | {
535 | public SKEIN512_160()
536 | : base(HashType.SKEIN512_160, "skein512-160", 160, () => new SkeinDigest(512, 160))
537 | {
538 | }
539 | }
540 |
541 | [Export(typeof(IMultihashAlgorithm))]
542 | [MultihashAlgorithmExport(HashType.SKEIN512_168, "skein512-168", 168)]
543 | public class SKEIN512_168 : SKEIN
544 | {
545 | public SKEIN512_168()
546 | : base(HashType.SKEIN512_168, "skein512-168", 168, () => new SkeinDigest(512, 168))
547 | {
548 | }
549 | }
550 |
551 | [Export(typeof(IMultihashAlgorithm))]
552 | [MultihashAlgorithmExport(HashType.SKEIN512_176, "skein512-176", 176)]
553 | public class SKEIN512_176 : SKEIN
554 | {
555 | public SKEIN512_176()
556 | : base(HashType.SKEIN512_176, "skein512-176", 176, () => new SkeinDigest(512, 176))
557 | {
558 | }
559 | }
560 |
561 | [Export(typeof(IMultihashAlgorithm))]
562 | [MultihashAlgorithmExport(HashType.SKEIN512_184, "skein512-184", 184)]
563 | public class SKEIN512_184 : SKEIN
564 | {
565 | public SKEIN512_184()
566 | : base(HashType.SKEIN512_184, "skein512-184", 184, () => new SkeinDigest(512, 184))
567 | {
568 | }
569 | }
570 |
571 | [Export(typeof(IMultihashAlgorithm))]
572 | [MultihashAlgorithmExport(HashType.SKEIN512_192, "skein512-192", 192)]
573 | public class SKEIN512_192 : SKEIN
574 | {
575 | public SKEIN512_192()
576 | : base(HashType.SKEIN512_192, "skein512-192", 192, () => new SkeinDigest(512, 192))
577 | {
578 | }
579 | }
580 |
581 | [Export(typeof(IMultihashAlgorithm))]
582 | [MultihashAlgorithmExport(HashType.SKEIN512_200, "skein512-200", 200)]
583 | public class SKEIN512_200 : SKEIN
584 | {
585 | public SKEIN512_200()
586 | : base(HashType.SKEIN512_200, "skein512-200", 200, () => new SkeinDigest(512, 200))
587 | {
588 | }
589 | }
590 |
591 | [Export(typeof(IMultihashAlgorithm))]
592 | [MultihashAlgorithmExport(HashType.SKEIN512_208, "skein512-208", 208)]
593 | public class SKEIN512_208 : SKEIN
594 | {
595 | public SKEIN512_208()
596 | : base(HashType.SKEIN512_208, "skein512-208", 208, () => new SkeinDigest(512, 208))
597 | {
598 | }
599 | }
600 |
601 | [Export(typeof(IMultihashAlgorithm))]
602 | [MultihashAlgorithmExport(HashType.SKEIN512_216, "skein512-216", 216)]
603 | public class SKEIN512_216 : SKEIN
604 | {
605 | public SKEIN512_216()
606 | : base(HashType.SKEIN512_216, "skein512-216", 216, () => new SkeinDigest(512, 216))
607 | {
608 | }
609 | }
610 |
611 | [Export(typeof(IMultihashAlgorithm))]
612 | [MultihashAlgorithmExport(HashType.SKEIN512_224, "skein512-224", 224)]
613 | public class SKEIN512_224 : SKEIN
614 | {
615 | public SKEIN512_224()
616 | : base(HashType.SKEIN512_224, "skein512-224", 224, () => new SkeinDigest(512, 224))
617 | {
618 | }
619 | }
620 |
621 | [Export(typeof(IMultihashAlgorithm))]
622 | [MultihashAlgorithmExport(HashType.SKEIN512_232, "skein512-232", 232)]
623 | public class SKEIN512_232 : SKEIN
624 | {
625 | public SKEIN512_232()
626 | : base(HashType.SKEIN512_232, "skein512-232", 232, () => new SkeinDigest(512, 232))
627 | {
628 | }
629 | }
630 |
631 | [Export(typeof(IMultihashAlgorithm))]
632 | [MultihashAlgorithmExport(HashType.SKEIN512_240, "skein512-240", 240)]
633 | public class SKEIN512_240 : SKEIN
634 | {
635 | public SKEIN512_240()
636 | : base(HashType.SKEIN512_240, "skein512-240", 240, () => new SkeinDigest(512, 240))
637 | {
638 | }
639 | }
640 |
641 | [Export(typeof(IMultihashAlgorithm))]
642 | [MultihashAlgorithmExport(HashType.SKEIN512_248, "skein512-248", 248)]
643 | public class SKEIN512_248 : SKEIN
644 | {
645 | public SKEIN512_248()
646 | : base(HashType.SKEIN512_248, "skein512-248", 248, () => new SkeinDigest(512, 248))
647 | {
648 | }
649 | }
650 |
651 | [Export(typeof(IMultihashAlgorithm))]
652 | [MultihashAlgorithmExport(HashType.SKEIN512_256, "skein512-256", 256)]
653 | public class SKEIN512_256 : SKEIN
654 | {
655 | public SKEIN512_256()
656 | : base(HashType.SKEIN512_256, "skein512-256", 256, () => new SkeinDigest(512, 256))
657 | {
658 | }
659 | }
660 |
661 | [Export(typeof(IMultihashAlgorithm))]
662 | [MultihashAlgorithmExport(HashType.SKEIN512_264, "skein512-264", 264)]
663 | public class SKEIN512_264 : SKEIN
664 | {
665 | public SKEIN512_264()
666 | : base(HashType.SKEIN512_264, "skein512-264", 264, () => new SkeinDigest(512, 264))
667 | {
668 | }
669 | }
670 |
671 | [Export(typeof(IMultihashAlgorithm))]
672 | [MultihashAlgorithmExport(HashType.SKEIN512_272, "skein512-272", 272)]
673 | public class SKEIN512_272 : SKEIN
674 | {
675 | public SKEIN512_272()
676 | : base(HashType.SKEIN512_272, "skein512-272", 272, () => new SkeinDigest(512, 272))
677 | {
678 | }
679 | }
680 |
681 | [Export(typeof(IMultihashAlgorithm))]
682 | [MultihashAlgorithmExport(HashType.SKEIN512_280, "skein512-280", 280)]
683 | public class SKEIN512_280 : SKEIN
684 | {
685 | public SKEIN512_280()
686 | : base(HashType.SKEIN512_280, "skein512-280", 280, () => new SkeinDigest(512, 280))
687 | {
688 | }
689 | }
690 |
691 | [Export(typeof(IMultihashAlgorithm))]
692 | [MultihashAlgorithmExport(HashType.SKEIN512_288, "skein512-288", 288)]
693 | public class SKEIN512_288 : SKEIN
694 | {
695 | public SKEIN512_288()
696 | : base(HashType.SKEIN512_288, "skein512-288", 288, () => new SkeinDigest(512, 288))
697 | {
698 | }
699 | }
700 |
701 | [Export(typeof(IMultihashAlgorithm))]
702 | [MultihashAlgorithmExport(HashType.SKEIN512_296, "skein512-296", 296)]
703 | public class SKEIN512_296 : SKEIN
704 | {
705 | public SKEIN512_296()
706 | : base(HashType.SKEIN512_296, "skein512-296", 296, () => new SkeinDigest(512, 296))
707 | {
708 | }
709 | }
710 |
711 | [Export(typeof(IMultihashAlgorithm))]
712 | [MultihashAlgorithmExport(HashType.SKEIN512_304, "skein512-304", 304)]
713 | public class SKEIN512_304 : SKEIN
714 | {
715 | public SKEIN512_304()
716 | : base(HashType.SKEIN512_304, "skein512-304", 304, () => new SkeinDigest(512, 304))
717 | {
718 | }
719 | }
720 |
721 | [Export(typeof(IMultihashAlgorithm))]
722 | [MultihashAlgorithmExport(HashType.SKEIN512_312, "skein512-312", 312)]
723 | public class SKEIN512_312 : SKEIN
724 | {
725 | public SKEIN512_312()
726 | : base(HashType.SKEIN512_312, "skein512-312", 312, () => new SkeinDigest(512, 312))
727 | {
728 | }
729 | }
730 |
731 | [Export(typeof(IMultihashAlgorithm))]
732 | [MultihashAlgorithmExport(HashType.SKEIN512_320, "skein512-320", 320)]
733 | public class SKEIN512_320 : SKEIN
734 | {
735 | public SKEIN512_320()
736 | : base(HashType.SKEIN512_320, "skein512-320", 320, () => new SkeinDigest(512, 320))
737 | {
738 | }
739 | }
740 |
741 | [Export(typeof(IMultihashAlgorithm))]
742 | [MultihashAlgorithmExport(HashType.SKEIN512_328, "skein512-328", 328)]
743 | public class SKEIN512_328 : SKEIN
744 | {
745 | public SKEIN512_328()
746 | : base(HashType.SKEIN512_328, "skein512-328", 328, () => new SkeinDigest(512, 328))
747 | {
748 | }
749 | }
750 |
751 | [Export(typeof(IMultihashAlgorithm))]
752 | [MultihashAlgorithmExport(HashType.SKEIN512_336, "skein512-336", 336)]
753 | public class SKEIN512_336 : SKEIN
754 | {
755 | public SKEIN512_336()
756 | : base(HashType.SKEIN512_336, "skein512-336", 336, () => new SkeinDigest(512, 336))
757 | {
758 | }
759 | }
760 |
761 | [Export(typeof(IMultihashAlgorithm))]
762 | [MultihashAlgorithmExport(HashType.SKEIN512_344, "skein512-344", 344)]
763 | public class SKEIN512_344 : SKEIN
764 | {
765 | public SKEIN512_344()
766 | : base(HashType.SKEIN512_344, "skein512-344", 344, () => new SkeinDigest(512, 344))
767 | {
768 | }
769 | }
770 |
771 | [Export(typeof(IMultihashAlgorithm))]
772 | [MultihashAlgorithmExport(HashType.SKEIN512_352, "skein512-352", 352)]
773 | public class SKEIN512_352 : SKEIN
774 | {
775 | public SKEIN512_352()
776 | : base(HashType.SKEIN512_352, "skein512-352", 352, () => new SkeinDigest(512, 352))
777 | {
778 | }
779 | }
780 |
781 | [Export(typeof(IMultihashAlgorithm))]
782 | [MultihashAlgorithmExport(HashType.SKEIN512_360, "skein512-360", 360)]
783 | public class SKEIN512_360 : SKEIN
784 | {
785 | public SKEIN512_360()
786 | : base(HashType.SKEIN512_360, "skein512-360", 360, () => new SkeinDigest(512, 360))
787 | {
788 | }
789 | }
790 |
791 | [Export(typeof(IMultihashAlgorithm))]
792 | [MultihashAlgorithmExport(HashType.SKEIN512_368, "skein512-368", 368)]
793 | public class SKEIN512_368 : SKEIN
794 | {
795 | public SKEIN512_368()
796 | : base(HashType.SKEIN512_368, "skein512-368", 368, () => new SkeinDigest(512, 368))
797 | {
798 | }
799 | }
800 |
801 | [Export(typeof(IMultihashAlgorithm))]
802 | [MultihashAlgorithmExport(HashType.SKEIN512_376, "skein512-376", 376)]
803 | public class SKEIN512_376 : SKEIN
804 | {
805 | public SKEIN512_376()
806 | : base(HashType.SKEIN512_376, "skein512-376", 376, () => new SkeinDigest(512, 376))
807 | {
808 | }
809 | }
810 |
811 | [Export(typeof(IMultihashAlgorithm))]
812 | [MultihashAlgorithmExport(HashType.SKEIN512_384, "skein512-384", 384)]
813 | public class SKEIN512_384 : SKEIN
814 | {
815 | public SKEIN512_384()
816 | : base(HashType.SKEIN512_384, "skein512-384", 384, () => new SkeinDigest(512, 384))
817 | {
818 | }
819 | }
820 |
821 | [Export(typeof(IMultihashAlgorithm))]
822 | [MultihashAlgorithmExport(HashType.SKEIN512_392, "skein512-392", 392)]
823 | public class SKEIN512_392 : SKEIN
824 | {
825 | public SKEIN512_392()
826 | : base(HashType.SKEIN512_392, "skein512-392", 392, () => new SkeinDigest(512, 392))
827 | {
828 | }
829 | }
830 |
831 | [Export(typeof(IMultihashAlgorithm))]
832 | [MultihashAlgorithmExport(HashType.SKEIN512_400, "skein512-400", 400)]
833 | public class SKEIN512_400 : SKEIN
834 | {
835 | public SKEIN512_400()
836 | : base(HashType.SKEIN512_400, "skein512-400", 400, () => new SkeinDigest(512, 400))
837 | {
838 | }
839 | }
840 |
841 | [Export(typeof(IMultihashAlgorithm))]
842 | [MultihashAlgorithmExport(HashType.SKEIN512_408, "skein512-408", 408)]
843 | public class SKEIN512_408 : SKEIN
844 | {
845 | public SKEIN512_408()
846 | : base(HashType.SKEIN512_408, "skein512-408", 408, () => new SkeinDigest(512, 408))
847 | {
848 | }
849 | }
850 |
851 | [Export(typeof(IMultihashAlgorithm))]
852 | [MultihashAlgorithmExport(HashType.SKEIN512_416, "skein512-416", 416)]
853 | public class SKEIN512_416 : SKEIN
854 | {
855 | public SKEIN512_416()
856 | : base(HashType.SKEIN512_416, "skein512-416", 416, () => new SkeinDigest(512, 416))
857 | {
858 | }
859 | }
860 |
861 | [Export(typeof(IMultihashAlgorithm))]
862 | [MultihashAlgorithmExport(HashType.SKEIN512_424, "skein512-424", 424)]
863 | public class SKEIN512_424 : SKEIN
864 | {
865 | public SKEIN512_424()
866 | : base(HashType.SKEIN512_424, "skein512-424", 424, () => new SkeinDigest(512, 424))
867 | {
868 | }
869 | }
870 |
871 | [Export(typeof(IMultihashAlgorithm))]
872 | [MultihashAlgorithmExport(HashType.SKEIN512_432, "skein512-432", 432)]
873 | public class SKEIN512_432 : SKEIN
874 | {
875 | public SKEIN512_432()
876 | : base(HashType.SKEIN512_432, "skein512-432", 432, () => new SkeinDigest(512, 432))
877 | {
878 | }
879 | }
880 |
881 | [Export(typeof(IMultihashAlgorithm))]
882 | [MultihashAlgorithmExport(HashType.SKEIN512_440, "skein512-440", 440)]
883 | public class SKEIN512_440 : SKEIN
884 | {
885 | public SKEIN512_440()
886 | : base(HashType.SKEIN512_440, "skein512-440", 440, () => new SkeinDigest(512, 440))
887 | {
888 | }
889 | }
890 |
891 | [Export(typeof(IMultihashAlgorithm))]
892 | [MultihashAlgorithmExport(HashType.SKEIN512_448, "skein512-448", 448)]
893 | public class SKEIN512_448 : SKEIN
894 | {
895 | public SKEIN512_448()
896 | : base(HashType.SKEIN512_448, "skein512-448", 448, () => new SkeinDigest(512, 448))
897 | {
898 | }
899 | }
900 |
901 | [Export(typeof(IMultihashAlgorithm))]
902 | [MultihashAlgorithmExport(HashType.SKEIN512_456, "skein512-456", 456)]
903 | public class SKEIN512_456 : SKEIN
904 | {
905 | public SKEIN512_456()
906 | : base(HashType.SKEIN512_456, "skein512-456", 456, () => new SkeinDigest(512, 456))
907 | {
908 | }
909 | }
910 |
911 | [Export(typeof(IMultihashAlgorithm))]
912 | [MultihashAlgorithmExport(HashType.SKEIN512_464, "skein512-464", 464)]
913 | public class SKEIN512_464 : SKEIN
914 | {
915 | public SKEIN512_464()
916 | : base(HashType.SKEIN512_464, "skein512-464", 464, () => new SkeinDigest(512, 464))
917 | {
918 | }
919 | }
920 |
921 | [Export(typeof(IMultihashAlgorithm))]
922 | [MultihashAlgorithmExport(HashType.SKEIN512_472, "skein512-472", 472)]
923 | public class SKEIN512_472 : SKEIN
924 | {
925 | public SKEIN512_472()
926 | : base(HashType.SKEIN512_472, "skein512-472", 472, () => new SkeinDigest(512, 472))
927 | {
928 | }
929 | }
930 |
931 | [Export(typeof(IMultihashAlgorithm))]
932 | [MultihashAlgorithmExport(HashType.SKEIN512_480, "skein512-480", 480)]
933 | public class SKEIN512_480 : SKEIN
934 | {
935 | public SKEIN512_480()
936 | : base(HashType.SKEIN512_480, "skein512-480", 480, () => new SkeinDigest(512, 480))
937 | {
938 | }
939 | }
940 |
941 | [Export(typeof(IMultihashAlgorithm))]
942 | [MultihashAlgorithmExport(HashType.SKEIN512_488, "skein512-488", 488)]
943 | public class SKEIN512_488 : SKEIN
944 | {
945 | public SKEIN512_488()
946 | : base(HashType.SKEIN512_488, "skein512-488", 488, () => new SkeinDigest(512, 488))
947 | {
948 | }
949 | }
950 |
951 | [Export(typeof(IMultihashAlgorithm))]
952 | [MultihashAlgorithmExport(HashType.SKEIN512_496, "skein512-496", 496)]
953 | public class SKEIN512_496 : SKEIN
954 | {
955 | public SKEIN512_496()
956 | : base(HashType.SKEIN512_496, "skein512-496", 496, () => new SkeinDigest(512, 496))
957 | {
958 | }
959 | }
960 |
961 | [Export(typeof(IMultihashAlgorithm))]
962 | [MultihashAlgorithmExport(HashType.SKEIN512_504, "skein512-504", 504)]
963 | public class SKEIN512_504 : SKEIN
964 | {
965 | public SKEIN512_504()
966 | : base(HashType.SKEIN512_504, "skein512-504", 504, () => new SkeinDigest(512, 504))
967 | {
968 | }
969 | }
970 |
971 | [Export(typeof(IMultihashAlgorithm))]
972 | [MultihashAlgorithmExport(HashType.SKEIN512_512, "skein512-512", 512)]
973 | public class SKEIN512_512 : SKEIN
974 | {
975 | public SKEIN512_512()
976 | : base(HashType.SKEIN512_512, "skein512-512", 512, () => new SkeinDigest(512, 512))
977 | {
978 | }
979 | }
980 |
981 | [Export(typeof(IMultihashAlgorithm))]
982 | [MultihashAlgorithmExport(HashType.SKEIN1024_8, "skein1024-8", 8)]
983 | public class SKEIN1024_8 : SKEIN
984 | {
985 | public SKEIN1024_8()
986 | : base(HashType.SKEIN1024_8, "skein1024-8", 8, () => new SkeinDigest(1024, 8))
987 | {
988 | }
989 | }
990 |
991 | [Export(typeof(IMultihashAlgorithm))]
992 | [MultihashAlgorithmExport(HashType.SKEIN1024_16, "skein1024-16", 16)]
993 | public class SKEIN1024_16 : SKEIN
994 | {
995 | public SKEIN1024_16()
996 | : base(HashType.SKEIN1024_16, "skein1024-16", 16, () => new SkeinDigest(1024, 16))
997 | {
998 | }
999 | }
1000 |
1001 | [Export(typeof(IMultihashAlgorithm))]
1002 | [MultihashAlgorithmExport(HashType.SKEIN1024_24, "skein1024-24", 24)]
1003 | public class SKEIN1024_24 : SKEIN
1004 | {
1005 | public SKEIN1024_24()
1006 | : base(HashType.SKEIN1024_24, "skein1024-24", 24, () => new SkeinDigest(1024, 24))
1007 | {
1008 | }
1009 | }
1010 |
1011 | [Export(typeof(IMultihashAlgorithm))]
1012 | [MultihashAlgorithmExport(HashType.SKEIN1024_32, "skein1024-32", 32)]
1013 | public class SKEIN1024_32 : SKEIN
1014 | {
1015 | public SKEIN1024_32()
1016 | : base(HashType.SKEIN1024_32, "skein1024-32", 32, () => new SkeinDigest(1024, 32))
1017 | {
1018 | }
1019 | }
1020 |
1021 | [Export(typeof(IMultihashAlgorithm))]
1022 | [MultihashAlgorithmExport(HashType.SKEIN1024_40, "skein1024-40", 40)]
1023 | public class SKEIN1024_40 : SKEIN
1024 | {
1025 | public SKEIN1024_40()
1026 | : base(HashType.SKEIN1024_40, "skein1024-40", 40, () => new SkeinDigest(1024, 40))
1027 | {
1028 | }
1029 | }
1030 |
1031 | [Export(typeof(IMultihashAlgorithm))]
1032 | [MultihashAlgorithmExport(HashType.SKEIN1024_48, "skein1024-48", 48)]
1033 | public class SKEIN1024_48 : SKEIN
1034 | {
1035 | public SKEIN1024_48()
1036 | : base(HashType.SKEIN1024_48, "skein1024-48", 48, () => new SkeinDigest(1024, 48))
1037 | {
1038 | }
1039 | }
1040 |
1041 | [Export(typeof(IMultihashAlgorithm))]
1042 | [MultihashAlgorithmExport(HashType.SKEIN1024_56, "skein1024-56", 56)]
1043 | public class SKEIN1024_56 : SKEIN
1044 | {
1045 | public SKEIN1024_56()
1046 | : base(HashType.SKEIN1024_56, "skein1024-56", 56, () => new SkeinDigest(1024, 56))
1047 | {
1048 | }
1049 | }
1050 |
1051 | [Export(typeof(IMultihashAlgorithm))]
1052 | [MultihashAlgorithmExport(HashType.SKEIN1024_64, "skein1024-64", 64)]
1053 | public class SKEIN1024_64 : SKEIN
1054 | {
1055 | public SKEIN1024_64()
1056 | : base(HashType.SKEIN1024_64, "skein1024-64", 64, () => new SkeinDigest(1024, 64))
1057 | {
1058 | }
1059 | }
1060 |
1061 | [Export(typeof(IMultihashAlgorithm))]
1062 | [MultihashAlgorithmExport(HashType.SKEIN1024_72, "skein1024-72", 72)]
1063 | public class SKEIN1024_72 : SKEIN
1064 | {
1065 | public SKEIN1024_72()
1066 | : base(HashType.SKEIN1024_72, "skein1024-72", 72, () => new SkeinDigest(1024, 72))
1067 | {
1068 | }
1069 | }
1070 |
1071 | [Export(typeof(IMultihashAlgorithm))]
1072 | [MultihashAlgorithmExport(HashType.SKEIN1024_80, "skein1024-80", 80)]
1073 | public class SKEIN1024_80 : SKEIN
1074 | {
1075 | public SKEIN1024_80()
1076 | : base(HashType.SKEIN1024_80, "skein1024-80", 80, () => new SkeinDigest(1024, 80))
1077 | {
1078 | }
1079 | }
1080 |
1081 | [Export(typeof(IMultihashAlgorithm))]
1082 | [MultihashAlgorithmExport(HashType.SKEIN1024_88, "skein1024-88", 88)]
1083 | public class SKEIN1024_88 : SKEIN
1084 | {
1085 | public SKEIN1024_88()
1086 | : base(HashType.SKEIN1024_88, "skein1024-88", 88, () => new SkeinDigest(1024, 88))
1087 | {
1088 | }
1089 | }
1090 |
1091 | [Export(typeof(IMultihashAlgorithm))]
1092 | [MultihashAlgorithmExport(HashType.SKEIN1024_96, "skein1024-96", 96)]
1093 | public class SKEIN1024_96 : SKEIN
1094 | {
1095 | public SKEIN1024_96()
1096 | : base(HashType.SKEIN1024_96, "skein1024-96", 96, () => new SkeinDigest(1024, 96))
1097 | {
1098 | }
1099 | }
1100 |
1101 | [Export(typeof(IMultihashAlgorithm))]
1102 | [MultihashAlgorithmExport(HashType.SKEIN1024_104, "skein1024-104", 104)]
1103 | public class SKEIN1024_104 : SKEIN
1104 | {
1105 | public SKEIN1024_104()
1106 | : base(HashType.SKEIN1024_104, "skein1024-104", 104, () => new SkeinDigest(1024, 104))
1107 | {
1108 | }
1109 | }
1110 |
1111 | [Export(typeof(IMultihashAlgorithm))]
1112 | [MultihashAlgorithmExport(HashType.SKEIN1024_112, "skein1024-112", 112)]
1113 | public class SKEIN1024_112 : SKEIN
1114 | {
1115 | public SKEIN1024_112()
1116 | : base(HashType.SKEIN1024_112, "skein1024-112", 112, () => new SkeinDigest(1024, 112))
1117 | {
1118 | }
1119 | }
1120 |
1121 | [Export(typeof(IMultihashAlgorithm))]
1122 | [MultihashAlgorithmExport(HashType.SKEIN1024_120, "skein1024-120", 120)]
1123 | public class SKEIN1024_120 : SKEIN
1124 | {
1125 | public SKEIN1024_120()
1126 | : base(HashType.SKEIN1024_120, "skein1024-120", 120, () => new SkeinDigest(1024, 120))
1127 | {
1128 | }
1129 | }
1130 |
1131 | [Export(typeof(IMultihashAlgorithm))]
1132 | [MultihashAlgorithmExport(HashType.SKEIN1024_128, "skein1024-128", 128)]
1133 | public class SKEIN1024_128 : SKEIN
1134 | {
1135 | public SKEIN1024_128()
1136 | : base(HashType.SKEIN1024_128, "skein1024-128", 128, () => new SkeinDigest(1024, 128))
1137 | {
1138 | }
1139 | }
1140 |
1141 | [Export(typeof(IMultihashAlgorithm))]
1142 | [MultihashAlgorithmExport(HashType.SKEIN1024_136, "skein1024-136", 136)]
1143 | public class SKEIN1024_136 : SKEIN
1144 | {
1145 | public SKEIN1024_136()
1146 | : base(HashType.SKEIN1024_136, "skein1024-136", 136, () => new SkeinDigest(1024, 136))
1147 | {
1148 | }
1149 | }
1150 |
1151 | [Export(typeof(IMultihashAlgorithm))]
1152 | [MultihashAlgorithmExport(HashType.SKEIN1024_144, "skein1024-144", 144)]
1153 | public class SKEIN1024_144 : SKEIN
1154 | {
1155 | public SKEIN1024_144()
1156 | : base(HashType.SKEIN1024_144, "skein1024-144", 144, () => new SkeinDigest(1024, 144))
1157 | {
1158 | }
1159 | }
1160 |
1161 | [Export(typeof(IMultihashAlgorithm))]
1162 | [MultihashAlgorithmExport(HashType.SKEIN1024_152, "skein1024-152", 152)]
1163 | public class SKEIN1024_152 : SKEIN
1164 | {
1165 | public SKEIN1024_152()
1166 | : base(HashType.SKEIN1024_152, "skein1024-152", 152, () => new SkeinDigest(1024, 152))
1167 | {
1168 | }
1169 | }
1170 |
1171 | [Export(typeof(IMultihashAlgorithm))]
1172 | [MultihashAlgorithmExport(HashType.SKEIN1024_160, "skein1024-160", 160)]
1173 | public class SKEIN1024_160 : SKEIN
1174 | {
1175 | public SKEIN1024_160()
1176 | : base(HashType.SKEIN1024_160, "skein1024-160", 160, () => new SkeinDigest(1024, 160))
1177 | {
1178 | }
1179 | }
1180 |
1181 | [Export(typeof(IMultihashAlgorithm))]
1182 | [MultihashAlgorithmExport(HashType.SKEIN1024_168, "skein1024-168", 168)]
1183 | public class SKEIN1024_168 : SKEIN
1184 | {
1185 | public SKEIN1024_168()
1186 | : base(HashType.SKEIN1024_168, "skein1024-168", 168, () => new SkeinDigest(1024, 168))
1187 | {
1188 | }
1189 | }
1190 |
1191 | [Export(typeof(IMultihashAlgorithm))]
1192 | [MultihashAlgorithmExport(HashType.SKEIN1024_176, "skein1024-176", 176)]
1193 | public class SKEIN1024_176 : SKEIN
1194 | {
1195 | public SKEIN1024_176()
1196 | : base(HashType.SKEIN1024_176, "skein1024-176", 176, () => new SkeinDigest(1024, 176))
1197 | {
1198 | }
1199 | }
1200 |
1201 | [Export(typeof(IMultihashAlgorithm))]
1202 | [MultihashAlgorithmExport(HashType.SKEIN1024_184, "skein1024-184", 184)]
1203 | public class SKEIN1024_184 : SKEIN
1204 | {
1205 | public SKEIN1024_184()
1206 | : base(HashType.SKEIN1024_184, "skein1024-184", 184, () => new SkeinDigest(1024, 184))
1207 | {
1208 | }
1209 | }
1210 |
1211 | [Export(typeof(IMultihashAlgorithm))]
1212 | [MultihashAlgorithmExport(HashType.SKEIN1024_192, "skein1024-192", 192)]
1213 | public class SKEIN1024_192 : SKEIN
1214 | {
1215 | public SKEIN1024_192()
1216 | : base(HashType.SKEIN1024_192, "skein1024-192", 192, () => new SkeinDigest(1024, 192))
1217 | {
1218 | }
1219 | }
1220 |
1221 | [Export(typeof(IMultihashAlgorithm))]
1222 | [MultihashAlgorithmExport(HashType.SKEIN1024_200, "skein1024-200", 200)]
1223 | public class SKEIN1024_200 : SKEIN
1224 | {
1225 | public SKEIN1024_200()
1226 | : base(HashType.SKEIN1024_200, "skein1024-200", 200, () => new SkeinDigest(1024, 200))
1227 | {
1228 | }
1229 | }
1230 |
1231 | [Export(typeof(IMultihashAlgorithm))]
1232 | [MultihashAlgorithmExport(HashType.SKEIN1024_208, "skein1024-208", 208)]
1233 | public class SKEIN1024_208 : SKEIN
1234 | {
1235 | public SKEIN1024_208()
1236 | : base(HashType.SKEIN1024_208, "skein1024-208", 208, () => new SkeinDigest(1024, 208))
1237 | {
1238 | }
1239 | }
1240 |
1241 | [Export(typeof(IMultihashAlgorithm))]
1242 | [MultihashAlgorithmExport(HashType.SKEIN1024_216, "skein1024-216", 216)]
1243 | public class SKEIN1024_216 : SKEIN
1244 | {
1245 | public SKEIN1024_216()
1246 | : base(HashType.SKEIN1024_216, "skein1024-216", 216, () => new SkeinDigest(1024, 216))
1247 | {
1248 | }
1249 | }
1250 |
1251 | [Export(typeof(IMultihashAlgorithm))]
1252 | [MultihashAlgorithmExport(HashType.SKEIN1024_224, "skein1024-224", 224)]
1253 | public class SKEIN1024_224 : SKEIN
1254 | {
1255 | public SKEIN1024_224()
1256 | : base(HashType.SKEIN1024_224, "skein1024-224", 224, () => new SkeinDigest(1024, 224))
1257 | {
1258 | }
1259 | }
1260 |
1261 | [Export(typeof(IMultihashAlgorithm))]
1262 | [MultihashAlgorithmExport(HashType.SKEIN1024_232, "skein1024-232", 232)]
1263 | public class SKEIN1024_232 : SKEIN
1264 | {
1265 | public SKEIN1024_232()
1266 | : base(HashType.SKEIN1024_232, "skein1024-232", 232, () => new SkeinDigest(1024, 232))
1267 | {
1268 | }
1269 | }
1270 |
1271 | [Export(typeof(IMultihashAlgorithm))]
1272 | [MultihashAlgorithmExport(HashType.SKEIN1024_240, "skein1024-240", 240)]
1273 | public class SKEIN1024_240 : SKEIN
1274 | {
1275 | public SKEIN1024_240()
1276 | : base(HashType.SKEIN1024_240, "skein1024-240", 240, () => new SkeinDigest(1024, 240))
1277 | {
1278 | }
1279 | }
1280 |
1281 | [Export(typeof(IMultihashAlgorithm))]
1282 | [MultihashAlgorithmExport(HashType.SKEIN1024_248, "skein1024-248", 248)]
1283 | public class SKEIN1024_248 : SKEIN
1284 | {
1285 | public SKEIN1024_248()
1286 | : base(HashType.SKEIN1024_248, "skein1024-248", 248, () => new SkeinDigest(1024, 248))
1287 | {
1288 | }
1289 | }
1290 |
1291 | [Export(typeof(IMultihashAlgorithm))]
1292 | [MultihashAlgorithmExport(HashType.SKEIN1024_256, "skein1024-256", 256)]
1293 | public class SKEIN1024_256 : SKEIN
1294 | {
1295 | public SKEIN1024_256()
1296 | : base(HashType.SKEIN1024_256, "skein1024-256", 256, () => new SkeinDigest(1024, 256))
1297 | {
1298 | }
1299 | }
1300 |
1301 | [Export(typeof(IMultihashAlgorithm))]
1302 | [MultihashAlgorithmExport(HashType.SKEIN1024_264, "skein1024-264", 264)]
1303 | public class SKEIN1024_264 : SKEIN
1304 | {
1305 | public SKEIN1024_264()
1306 | : base(HashType.SKEIN1024_264, "skein1024-264", 264, () => new SkeinDigest(1024, 264))
1307 | {
1308 | }
1309 | }
1310 |
1311 | [Export(typeof(IMultihashAlgorithm))]
1312 | [MultihashAlgorithmExport(HashType.SKEIN1024_272, "skein1024-272", 272)]
1313 | public class SKEIN1024_272 : SKEIN
1314 | {
1315 | public SKEIN1024_272()
1316 | : base(HashType.SKEIN1024_272, "skein1024-272", 272, () => new SkeinDigest(1024, 272))
1317 | {
1318 | }
1319 | }
1320 |
1321 | [Export(typeof(IMultihashAlgorithm))]
1322 | [MultihashAlgorithmExport(HashType.SKEIN1024_280, "skein1024-280", 280)]
1323 | public class SKEIN1024_280 : SKEIN
1324 | {
1325 | public SKEIN1024_280()
1326 | : base(HashType.SKEIN1024_280, "skein1024-280", 280, () => new SkeinDigest(1024, 280))
1327 | {
1328 | }
1329 | }
1330 |
1331 | [Export(typeof(IMultihashAlgorithm))]
1332 | [MultihashAlgorithmExport(HashType.SKEIN1024_288, "skein1024-288", 288)]
1333 | public class SKEIN1024_288 : SKEIN
1334 | {
1335 | public SKEIN1024_288()
1336 | : base(HashType.SKEIN1024_288, "skein1024-288", 288, () => new SkeinDigest(1024, 288))
1337 | {
1338 | }
1339 | }
1340 |
1341 | [Export(typeof(IMultihashAlgorithm))]
1342 | [MultihashAlgorithmExport(HashType.SKEIN1024_296, "skein1024-296", 296)]
1343 | public class SKEIN1024_296 : SKEIN
1344 | {
1345 | public SKEIN1024_296()
1346 | : base(HashType.SKEIN1024_296, "skein1024-296", 296, () => new SkeinDigest(1024, 296))
1347 | {
1348 | }
1349 | }
1350 |
1351 | [Export(typeof(IMultihashAlgorithm))]
1352 | [MultihashAlgorithmExport(HashType.SKEIN1024_304, "skein1024-304", 304)]
1353 | public class SKEIN1024_304 : SKEIN
1354 | {
1355 | public SKEIN1024_304()
1356 | : base(HashType.SKEIN1024_304, "skein1024-304", 304, () => new SkeinDigest(1024, 304))
1357 | {
1358 | }
1359 | }
1360 |
1361 | [Export(typeof(IMultihashAlgorithm))]
1362 | [MultihashAlgorithmExport(HashType.SKEIN1024_312, "skein1024-312", 312)]
1363 | public class SKEIN1024_312 : SKEIN
1364 | {
1365 | public SKEIN1024_312()
1366 | : base(HashType.SKEIN1024_312, "skein1024-312", 312, () => new SkeinDigest(1024, 312))
1367 | {
1368 | }
1369 | }
1370 |
1371 | [Export(typeof(IMultihashAlgorithm))]
1372 | [MultihashAlgorithmExport(HashType.SKEIN1024_320, "skein1024-320", 320)]
1373 | public class SKEIN1024_320 : SKEIN
1374 | {
1375 | public SKEIN1024_320()
1376 | : base(HashType.SKEIN1024_320, "skein1024-320", 320, () => new SkeinDigest(1024, 320))
1377 | {
1378 | }
1379 | }
1380 |
1381 | [Export(typeof(IMultihashAlgorithm))]
1382 | [MultihashAlgorithmExport(HashType.SKEIN1024_328, "skein1024-328", 328)]
1383 | public class SKEIN1024_328 : SKEIN
1384 | {
1385 | public SKEIN1024_328()
1386 | : base(HashType.SKEIN1024_328, "skein1024-328", 328, () => new SkeinDigest(1024, 328))
1387 | {
1388 | }
1389 | }
1390 |
1391 | [Export(typeof(IMultihashAlgorithm))]
1392 | [MultihashAlgorithmExport(HashType.SKEIN1024_336, "skein1024-336", 336)]
1393 | public class SKEIN1024_336 : SKEIN
1394 | {
1395 | public SKEIN1024_336()
1396 | : base(HashType.SKEIN1024_336, "skein1024-336", 336, () => new SkeinDigest(1024, 336))
1397 | {
1398 | }
1399 | }
1400 |
1401 | [Export(typeof(IMultihashAlgorithm))]
1402 | [MultihashAlgorithmExport(HashType.SKEIN1024_344, "skein1024-344", 344)]
1403 | public class SKEIN1024_344 : SKEIN
1404 | {
1405 | public SKEIN1024_344()
1406 | : base(HashType.SKEIN1024_344, "skein1024-344", 344, () => new SkeinDigest(1024, 344))
1407 | {
1408 | }
1409 | }
1410 |
1411 | [Export(typeof(IMultihashAlgorithm))]
1412 | [MultihashAlgorithmExport(HashType.SKEIN1024_352, "skein1024-352", 352)]
1413 | public class SKEIN1024_352 : SKEIN
1414 | {
1415 | public SKEIN1024_352()
1416 | : base(HashType.SKEIN1024_352, "skein1024-352", 352, () => new SkeinDigest(1024, 352))
1417 | {
1418 | }
1419 | }
1420 |
1421 | [Export(typeof(IMultihashAlgorithm))]
1422 | [MultihashAlgorithmExport(HashType.SKEIN1024_360, "skein1024-360", 360)]
1423 | public class SKEIN1024_360 : SKEIN
1424 | {
1425 | public SKEIN1024_360()
1426 | : base(HashType.SKEIN1024_360, "skein1024-360", 360, () => new SkeinDigest(1024, 360))
1427 | {
1428 | }
1429 | }
1430 |
1431 | [Export(typeof(IMultihashAlgorithm))]
1432 | [MultihashAlgorithmExport(HashType.SKEIN1024_368, "skein1024-368", 368)]
1433 | public class SKEIN1024_368 : SKEIN
1434 | {
1435 | public SKEIN1024_368()
1436 | : base(HashType.SKEIN1024_368, "skein1024-368", 368, () => new SkeinDigest(1024, 368))
1437 | {
1438 | }
1439 | }
1440 |
1441 | [Export(typeof(IMultihashAlgorithm))]
1442 | [MultihashAlgorithmExport(HashType.SKEIN1024_376, "skein1024-376", 376)]
1443 | public class SKEIN1024_376 : SKEIN
1444 | {
1445 | public SKEIN1024_376()
1446 | : base(HashType.SKEIN1024_376, "skein1024-376", 376, () => new SkeinDigest(1024, 376))
1447 | {
1448 | }
1449 | }
1450 |
1451 | [Export(typeof(IMultihashAlgorithm))]
1452 | [MultihashAlgorithmExport(HashType.SKEIN1024_384, "skein1024-384", 384)]
1453 | public class SKEIN1024_384 : SKEIN
1454 | {
1455 | public SKEIN1024_384()
1456 | : base(HashType.SKEIN1024_384, "skein1024-384", 384, () => new SkeinDigest(1024, 384))
1457 | {
1458 | }
1459 | }
1460 |
1461 | [Export(typeof(IMultihashAlgorithm))]
1462 | [MultihashAlgorithmExport(HashType.SKEIN1024_392, "skein1024-392", 392)]
1463 | public class SKEIN1024_392 : SKEIN
1464 | {
1465 | public SKEIN1024_392()
1466 | : base(HashType.SKEIN1024_392, "skein1024-392", 392, () => new SkeinDigest(1024, 392))
1467 | {
1468 | }
1469 | }
1470 |
1471 | [Export(typeof(IMultihashAlgorithm))]
1472 | [MultihashAlgorithmExport(HashType.SKEIN1024_400, "skein1024-400", 400)]
1473 | public class SKEIN1024_400 : SKEIN
1474 | {
1475 | public SKEIN1024_400()
1476 | : base(HashType.SKEIN1024_400, "skein1024-400", 400, () => new SkeinDigest(1024, 400))
1477 | {
1478 | }
1479 | }
1480 |
1481 | [Export(typeof(IMultihashAlgorithm))]
1482 | [MultihashAlgorithmExport(HashType.SKEIN1024_408, "skein1024-408", 408)]
1483 | public class SKEIN1024_408 : SKEIN
1484 | {
1485 | public SKEIN1024_408()
1486 | : base(HashType.SKEIN1024_408, "skein1024-408", 408, () => new SkeinDigest(1024, 408))
1487 | {
1488 | }
1489 | }
1490 |
1491 | [Export(typeof(IMultihashAlgorithm))]
1492 | [MultihashAlgorithmExport(HashType.SKEIN1024_416, "skein1024-416", 416)]
1493 | public class SKEIN1024_416 : SKEIN
1494 | {
1495 | public SKEIN1024_416()
1496 | : base(HashType.SKEIN1024_416, "skein1024-416", 416, () => new SkeinDigest(1024, 416))
1497 | {
1498 | }
1499 | }
1500 |
1501 | [Export(typeof(IMultihashAlgorithm))]
1502 | [MultihashAlgorithmExport(HashType.SKEIN1024_424, "skein1024-424", 424)]
1503 | public class SKEIN1024_424 : SKEIN
1504 | {
1505 | public SKEIN1024_424()
1506 | : base(HashType.SKEIN1024_424, "skein1024-424", 424, () => new SkeinDigest(1024, 424))
1507 | {
1508 | }
1509 | }
1510 |
1511 | [Export(typeof(IMultihashAlgorithm))]
1512 | [MultihashAlgorithmExport(HashType.SKEIN1024_432, "skein1024-432", 432)]
1513 | public class SKEIN1024_432 : SKEIN
1514 | {
1515 | public SKEIN1024_432()
1516 | : base(HashType.SKEIN1024_432, "skein1024-432", 432, () => new SkeinDigest(1024, 432))
1517 | {
1518 | }
1519 | }
1520 |
1521 | [Export(typeof(IMultihashAlgorithm))]
1522 | [MultihashAlgorithmExport(HashType.SKEIN1024_440, "skein1024-440", 440)]
1523 | public class SKEIN1024_440 : SKEIN
1524 | {
1525 | public SKEIN1024_440()
1526 | : base(HashType.SKEIN1024_440, "skein1024-440", 440, () => new SkeinDigest(1024, 440))
1527 | {
1528 | }
1529 | }
1530 |
1531 | [Export(typeof(IMultihashAlgorithm))]
1532 | [MultihashAlgorithmExport(HashType.SKEIN1024_448, "skein1024-448", 448)]
1533 | public class SKEIN1024_448 : SKEIN
1534 | {
1535 | public SKEIN1024_448()
1536 | : base(HashType.SKEIN1024_448, "skein1024-448", 448, () => new SkeinDigest(1024, 448))
1537 | {
1538 | }
1539 | }
1540 |
1541 | [Export(typeof(IMultihashAlgorithm))]
1542 | [MultihashAlgorithmExport(HashType.SKEIN1024_456, "skein1024-456", 456)]
1543 | public class SKEIN1024_456 : SKEIN
1544 | {
1545 | public SKEIN1024_456()
1546 | : base(HashType.SKEIN1024_456, "skein1024-456", 456, () => new SkeinDigest(1024, 456))
1547 | {
1548 | }
1549 | }
1550 |
1551 | [Export(typeof(IMultihashAlgorithm))]
1552 | [MultihashAlgorithmExport(HashType.SKEIN1024_464, "skein1024-464", 464)]
1553 | public class SKEIN1024_464 : SKEIN
1554 | {
1555 | public SKEIN1024_464()
1556 | : base(HashType.SKEIN1024_464, "skein1024-464", 464, () => new SkeinDigest(1024, 464))
1557 | {
1558 | }
1559 | }
1560 |
1561 | [Export(typeof(IMultihashAlgorithm))]
1562 | [MultihashAlgorithmExport(HashType.SKEIN1024_472, "skein1024-472", 472)]
1563 | public class SKEIN1024_472 : SKEIN
1564 | {
1565 | public SKEIN1024_472()
1566 | : base(HashType.SKEIN1024_472, "skein1024-472", 472, () => new SkeinDigest(1024, 472))
1567 | {
1568 | }
1569 | }
1570 |
1571 | [Export(typeof(IMultihashAlgorithm))]
1572 | [MultihashAlgorithmExport(HashType.SKEIN1024_480, "skein1024-480", 480)]
1573 | public class SKEIN1024_480 : SKEIN
1574 | {
1575 | public SKEIN1024_480()
1576 | : base(HashType.SKEIN1024_480, "skein1024-480", 480, () => new SkeinDigest(1024, 480))
1577 | {
1578 | }
1579 | }
1580 |
1581 | [Export(typeof(IMultihashAlgorithm))]
1582 | [MultihashAlgorithmExport(HashType.SKEIN1024_488, "skein1024-488", 488)]
1583 | public class SKEIN1024_488 : SKEIN
1584 | {
1585 | public SKEIN1024_488()
1586 | : base(HashType.SKEIN1024_488, "skein1024-488", 488, () => new SkeinDigest(1024, 488))
1587 | {
1588 | }
1589 | }
1590 |
1591 | [Export(typeof(IMultihashAlgorithm))]
1592 | [MultihashAlgorithmExport(HashType.SKEIN1024_496, "skein1024-496", 496)]
1593 | public class SKEIN1024_496 : SKEIN
1594 | {
1595 | public SKEIN1024_496()
1596 | : base(HashType.SKEIN1024_496, "skein1024-496", 496, () => new SkeinDigest(1024, 496))
1597 | {
1598 | }
1599 | }
1600 |
1601 | [Export(typeof(IMultihashAlgorithm))]
1602 | [MultihashAlgorithmExport(HashType.SKEIN1024_504, "skein1024-504", 504)]
1603 | public class SKEIN1024_504 : SKEIN
1604 | {
1605 | public SKEIN1024_504()
1606 | : base(HashType.SKEIN1024_504, "skein1024-504", 504, () => new SkeinDigest(1024, 504))
1607 | {
1608 | }
1609 | }
1610 |
1611 | [Export(typeof(IMultihashAlgorithm))]
1612 | [MultihashAlgorithmExport(HashType.SKEIN1024_512, "skein1024-512", 512)]
1613 | public class SKEIN1024_512 : SKEIN
1614 | {
1615 | public SKEIN1024_512()
1616 | : base(HashType.SKEIN1024_512, "skein1024-512", 512, () => new SkeinDigest(1024, 512))
1617 | {
1618 | }
1619 | }
1620 |
1621 | [Export(typeof(IMultihashAlgorithm))]
1622 | [MultihashAlgorithmExport(HashType.SKEIN1024_520, "skein1024-520", 520)]
1623 | public class SKEIN1024_520 : SKEIN
1624 | {
1625 | public SKEIN1024_520()
1626 | : base(HashType.SKEIN1024_520, "skein1024-520", 520, () => new SkeinDigest(1024, 520))
1627 | {
1628 | }
1629 | }
1630 |
1631 | [Export(typeof(IMultihashAlgorithm))]
1632 | [MultihashAlgorithmExport(HashType.SKEIN1024_528, "skein1024-528", 528)]
1633 | public class SKEIN1024_528 : SKEIN
1634 | {
1635 | public SKEIN1024_528()
1636 | : base(HashType.SKEIN1024_528, "skein1024-528", 528, () => new SkeinDigest(1024, 528))
1637 | {
1638 | }
1639 | }
1640 |
1641 | [Export(typeof(IMultihashAlgorithm))]
1642 | [MultihashAlgorithmExport(HashType.SKEIN1024_536, "skein1024-536", 536)]
1643 | public class SKEIN1024_536 : SKEIN
1644 | {
1645 | public SKEIN1024_536()
1646 | : base(HashType.SKEIN1024_536, "skein1024-536", 536, () => new SkeinDigest(1024, 536))
1647 | {
1648 | }
1649 | }
1650 |
1651 | [Export(typeof(IMultihashAlgorithm))]
1652 | [MultihashAlgorithmExport(HashType.SKEIN1024_544, "skein1024-544", 544)]
1653 | public class SKEIN1024_544 : SKEIN
1654 | {
1655 | public SKEIN1024_544()
1656 | : base(HashType.SKEIN1024_544, "skein1024-544", 544, () => new SkeinDigest(1024, 544))
1657 | {
1658 | }
1659 | }
1660 |
1661 | [Export(typeof(IMultihashAlgorithm))]
1662 | [MultihashAlgorithmExport(HashType.SKEIN1024_552, "skein1024-552", 552)]
1663 | public class SKEIN1024_552 : SKEIN
1664 | {
1665 | public SKEIN1024_552()
1666 | : base(HashType.SKEIN1024_552, "skein1024-552", 552, () => new SkeinDigest(1024, 552))
1667 | {
1668 | }
1669 | }
1670 |
1671 | [Export(typeof(IMultihashAlgorithm))]
1672 | [MultihashAlgorithmExport(HashType.SKEIN1024_560, "skein1024-560", 560)]
1673 | public class SKEIN1024_560 : SKEIN
1674 | {
1675 | public SKEIN1024_560()
1676 | : base(HashType.SKEIN1024_560, "skein1024-560", 560, () => new SkeinDigest(1024, 560))
1677 | {
1678 | }
1679 | }
1680 |
1681 | [Export(typeof(IMultihashAlgorithm))]
1682 | [MultihashAlgorithmExport(HashType.SKEIN1024_568, "skein1024-568", 568)]
1683 | public class SKEIN1024_568 : SKEIN
1684 | {
1685 | public SKEIN1024_568()
1686 | : base(HashType.SKEIN1024_568, "skein1024-568", 568, () => new SkeinDigest(1024, 568))
1687 | {
1688 | }
1689 | }
1690 |
1691 | [Export(typeof(IMultihashAlgorithm))]
1692 | [MultihashAlgorithmExport(HashType.SKEIN1024_576, "skein1024-576", 576)]
1693 | public class SKEIN1024_576 : SKEIN
1694 | {
1695 | public SKEIN1024_576()
1696 | : base(HashType.SKEIN1024_576, "skein1024-576", 576, () => new SkeinDigest(1024, 576))
1697 | {
1698 | }
1699 | }
1700 |
1701 | [Export(typeof(IMultihashAlgorithm))]
1702 | [MultihashAlgorithmExport(HashType.SKEIN1024_584, "skein1024-584", 584)]
1703 | public class SKEIN1024_584 : SKEIN
1704 | {
1705 | public SKEIN1024_584()
1706 | : base(HashType.SKEIN1024_584, "skein1024-584", 584, () => new SkeinDigest(1024, 584))
1707 | {
1708 | }
1709 | }
1710 |
1711 | [Export(typeof(IMultihashAlgorithm))]
1712 | [MultihashAlgorithmExport(HashType.SKEIN1024_592, "skein1024-592", 592)]
1713 | public class SKEIN1024_592 : SKEIN
1714 | {
1715 | public SKEIN1024_592()
1716 | : base(HashType.SKEIN1024_592, "skein1024-592", 592, () => new SkeinDigest(1024, 592))
1717 | {
1718 | }
1719 | }
1720 |
1721 | [Export(typeof(IMultihashAlgorithm))]
1722 | [MultihashAlgorithmExport(HashType.SKEIN1024_600, "skein1024-600", 600)]
1723 | public class SKEIN1024_600 : SKEIN
1724 | {
1725 | public SKEIN1024_600()
1726 | : base(HashType.SKEIN1024_600, "skein1024-600", 600, () => new SkeinDigest(1024, 600))
1727 | {
1728 | }
1729 | }
1730 |
1731 | [Export(typeof(IMultihashAlgorithm))]
1732 | [MultihashAlgorithmExport(HashType.SKEIN1024_608, "skein1024-608", 608)]
1733 | public class SKEIN1024_608 : SKEIN
1734 | {
1735 | public SKEIN1024_608()
1736 | : base(HashType.SKEIN1024_608, "skein1024-608", 608, () => new SkeinDigest(1024, 608))
1737 | {
1738 | }
1739 | }
1740 |
1741 | [Export(typeof(IMultihashAlgorithm))]
1742 | [MultihashAlgorithmExport(HashType.SKEIN1024_616, "skein1024-616", 616)]
1743 | public class SKEIN1024_616 : SKEIN
1744 | {
1745 | public SKEIN1024_616()
1746 | : base(HashType.SKEIN1024_616, "skein1024-616", 616, () => new SkeinDigest(1024, 616))
1747 | {
1748 | }
1749 | }
1750 |
1751 | [Export(typeof(IMultihashAlgorithm))]
1752 | [MultihashAlgorithmExport(HashType.SKEIN1024_624, "skein1024-624", 624)]
1753 | public class SKEIN1024_624 : SKEIN
1754 | {
1755 | public SKEIN1024_624()
1756 | : base(HashType.SKEIN1024_624, "skein1024-624", 624, () => new SkeinDigest(1024, 624))
1757 | {
1758 | }
1759 | }
1760 |
1761 | [Export(typeof(IMultihashAlgorithm))]
1762 | [MultihashAlgorithmExport(HashType.SKEIN1024_632, "skein1024-632", 632)]
1763 | public class SKEIN1024_632 : SKEIN
1764 | {
1765 | public SKEIN1024_632()
1766 | : base(HashType.SKEIN1024_632, "skein1024-632", 632, () => new SkeinDigest(1024, 632))
1767 | {
1768 | }
1769 | }
1770 |
1771 | [Export(typeof(IMultihashAlgorithm))]
1772 | [MultihashAlgorithmExport(HashType.SKEIN1024_640, "skein1024-640", 640)]
1773 | public class SKEIN1024_640 : SKEIN
1774 | {
1775 | public SKEIN1024_640()
1776 | : base(HashType.SKEIN1024_640, "skein1024-640", 640, () => new SkeinDigest(1024, 640))
1777 | {
1778 | }
1779 | }
1780 |
1781 | [Export(typeof(IMultihashAlgorithm))]
1782 | [MultihashAlgorithmExport(HashType.SKEIN1024_648, "skein1024-648", 648)]
1783 | public class SKEIN1024_648 : SKEIN
1784 | {
1785 | public SKEIN1024_648()
1786 | : base(HashType.SKEIN1024_648, "skein1024-648", 648, () => new SkeinDigest(1024, 648))
1787 | {
1788 | }
1789 | }
1790 |
1791 | [Export(typeof(IMultihashAlgorithm))]
1792 | [MultihashAlgorithmExport(HashType.SKEIN1024_656, "skein1024-656", 656)]
1793 | public class SKEIN1024_656 : SKEIN
1794 | {
1795 | public SKEIN1024_656()
1796 | : base(HashType.SKEIN1024_656, "skein1024-656", 656, () => new SkeinDigest(1024, 656))
1797 | {
1798 | }
1799 | }
1800 |
1801 | [Export(typeof(IMultihashAlgorithm))]
1802 | [MultihashAlgorithmExport(HashType.SKEIN1024_664, "skein1024-664", 664)]
1803 | public class SKEIN1024_664 : SKEIN
1804 | {
1805 | public SKEIN1024_664()
1806 | : base(HashType.SKEIN1024_664, "skein1024-664", 664, () => new SkeinDigest(1024, 664))
1807 | {
1808 | }
1809 | }
1810 |
1811 | [Export(typeof(IMultihashAlgorithm))]
1812 | [MultihashAlgorithmExport(HashType.SKEIN1024_672, "skein1024-672", 672)]
1813 | public class SKEIN1024_672 : SKEIN
1814 | {
1815 | public SKEIN1024_672()
1816 | : base(HashType.SKEIN1024_672, "skein1024-672", 672, () => new SkeinDigest(1024, 672))
1817 | {
1818 | }
1819 | }
1820 |
1821 | [Export(typeof(IMultihashAlgorithm))]
1822 | [MultihashAlgorithmExport(HashType.SKEIN1024_680, "skein1024-680", 680)]
1823 | public class SKEIN1024_680 : SKEIN
1824 | {
1825 | public SKEIN1024_680()
1826 | : base(HashType.SKEIN1024_680, "skein1024-680", 680, () => new SkeinDigest(1024, 680))
1827 | {
1828 | }
1829 | }
1830 |
1831 | [Export(typeof(IMultihashAlgorithm))]
1832 | [MultihashAlgorithmExport(HashType.SKEIN1024_688, "skein1024-688", 688)]
1833 | public class SKEIN1024_688 : SKEIN
1834 | {
1835 | public SKEIN1024_688()
1836 | : base(HashType.SKEIN1024_688, "skein1024-688", 688, () => new SkeinDigest(1024, 688))
1837 | {
1838 | }
1839 | }
1840 |
1841 | [Export(typeof(IMultihashAlgorithm))]
1842 | [MultihashAlgorithmExport(HashType.SKEIN1024_696, "skein1024-696", 696)]
1843 | public class SKEIN1024_696 : SKEIN
1844 | {
1845 | public SKEIN1024_696()
1846 | : base(HashType.SKEIN1024_696, "skein1024-696", 696, () => new SkeinDigest(1024, 696))
1847 | {
1848 | }
1849 | }
1850 |
1851 | [Export(typeof(IMultihashAlgorithm))]
1852 | [MultihashAlgorithmExport(HashType.SKEIN1024_704, "skein1024-704", 704)]
1853 | public class SKEIN1024_704 : SKEIN
1854 | {
1855 | public SKEIN1024_704()
1856 | : base(HashType.SKEIN1024_704, "skein1024-704", 704, () => new SkeinDigest(1024, 704))
1857 | {
1858 | }
1859 | }
1860 |
1861 | [Export(typeof(IMultihashAlgorithm))]
1862 | [MultihashAlgorithmExport(HashType.SKEIN1024_712, "skein1024-712", 712)]
1863 | public class SKEIN1024_712 : SKEIN
1864 | {
1865 | public SKEIN1024_712()
1866 | : base(HashType.SKEIN1024_712, "skein1024-712", 712, () => new SkeinDigest(1024, 712))
1867 | {
1868 | }
1869 | }
1870 |
1871 | [Export(typeof(IMultihashAlgorithm))]
1872 | [MultihashAlgorithmExport(HashType.SKEIN1024_720, "skein1024-720", 720)]
1873 | public class SKEIN1024_720 : SKEIN
1874 | {
1875 | public SKEIN1024_720()
1876 | : base(HashType.SKEIN1024_720, "skein1024-720", 720, () => new SkeinDigest(1024, 720))
1877 | {
1878 | }
1879 | }
1880 |
1881 | [Export(typeof(IMultihashAlgorithm))]
1882 | [MultihashAlgorithmExport(HashType.SKEIN1024_728, "skein1024-728", 728)]
1883 | public class SKEIN1024_728 : SKEIN
1884 | {
1885 | public SKEIN1024_728()
1886 | : base(HashType.SKEIN1024_728, "skein1024-728", 728, () => new SkeinDigest(1024, 728))
1887 | {
1888 | }
1889 | }
1890 |
1891 | [Export(typeof(IMultihashAlgorithm))]
1892 | [MultihashAlgorithmExport(HashType.SKEIN1024_736, "skein1024-736", 736)]
1893 | public class SKEIN1024_736 : SKEIN
1894 | {
1895 | public SKEIN1024_736()
1896 | : base(HashType.SKEIN1024_736, "skein1024-736", 736, () => new SkeinDigest(1024, 736))
1897 | {
1898 | }
1899 | }
1900 |
1901 | [Export(typeof(IMultihashAlgorithm))]
1902 | [MultihashAlgorithmExport(HashType.SKEIN1024_744, "skein1024-744", 744)]
1903 | public class SKEIN1024_744 : SKEIN
1904 | {
1905 | public SKEIN1024_744()
1906 | : base(HashType.SKEIN1024_744, "skein1024-744", 744, () => new SkeinDigest(1024, 744))
1907 | {
1908 | }
1909 | }
1910 |
1911 | [Export(typeof(IMultihashAlgorithm))]
1912 | [MultihashAlgorithmExport(HashType.SKEIN1024_752, "skein1024-752", 752)]
1913 | public class SKEIN1024_752 : SKEIN
1914 | {
1915 | public SKEIN1024_752()
1916 | : base(HashType.SKEIN1024_752, "skein1024-752", 752, () => new SkeinDigest(1024, 752))
1917 | {
1918 | }
1919 | }
1920 |
1921 | [Export(typeof(IMultihashAlgorithm))]
1922 | [MultihashAlgorithmExport(HashType.SKEIN1024_760, "skein1024-760", 760)]
1923 | public class SKEIN1024_760 : SKEIN
1924 | {
1925 | public SKEIN1024_760()
1926 | : base(HashType.SKEIN1024_760, "skein1024-760", 760, () => new SkeinDigest(1024, 760))
1927 | {
1928 | }
1929 | }
1930 |
1931 | [Export(typeof(IMultihashAlgorithm))]
1932 | [MultihashAlgorithmExport(HashType.SKEIN1024_768, "skein1024-768", 768)]
1933 | public class SKEIN1024_768 : SKEIN
1934 | {
1935 | public SKEIN1024_768()
1936 | : base(HashType.SKEIN1024_768, "skein1024-768", 768, () => new SkeinDigest(1024, 768))
1937 | {
1938 | }
1939 | }
1940 |
1941 | [Export(typeof(IMultihashAlgorithm))]
1942 | [MultihashAlgorithmExport(HashType.SKEIN1024_776, "skein1024-776", 776)]
1943 | public class SKEIN1024_776 : SKEIN
1944 | {
1945 | public SKEIN1024_776()
1946 | : base(HashType.SKEIN1024_776, "skein1024-776", 776, () => new SkeinDigest(1024, 776))
1947 | {
1948 | }
1949 | }
1950 |
1951 | [Export(typeof(IMultihashAlgorithm))]
1952 | [MultihashAlgorithmExport(HashType.SKEIN1024_784, "skein1024-784", 784)]
1953 | public class SKEIN1024_784 : SKEIN
1954 | {
1955 | public SKEIN1024_784()
1956 | : base(HashType.SKEIN1024_784, "skein1024-784", 784, () => new SkeinDigest(1024, 784))
1957 | {
1958 | }
1959 | }
1960 |
1961 | [Export(typeof(IMultihashAlgorithm))]
1962 | [MultihashAlgorithmExport(HashType.SKEIN1024_792, "skein1024-792", 792)]
1963 | public class SKEIN1024_792 : SKEIN
1964 | {
1965 | public SKEIN1024_792()
1966 | : base(HashType.SKEIN1024_792, "skein1024-792", 792, () => new SkeinDigest(1024, 792))
1967 | {
1968 | }
1969 | }
1970 |
1971 | [Export(typeof(IMultihashAlgorithm))]
1972 | [MultihashAlgorithmExport(HashType.SKEIN1024_800, "skein1024-800", 800)]
1973 | public class SKEIN1024_800 : SKEIN
1974 | {
1975 | public SKEIN1024_800()
1976 | : base(HashType.SKEIN1024_800, "skein1024-800", 800, () => new SkeinDigest(1024, 800))
1977 | {
1978 | }
1979 | }
1980 |
1981 | [Export(typeof(IMultihashAlgorithm))]
1982 | [MultihashAlgorithmExport(HashType.SKEIN1024_808, "skein1024-808", 808)]
1983 | public class SKEIN1024_808 : SKEIN
1984 | {
1985 | public SKEIN1024_808()
1986 | : base(HashType.SKEIN1024_808, "skein1024-808", 808, () => new SkeinDigest(1024, 808))
1987 | {
1988 | }
1989 | }
1990 |
1991 | [Export(typeof(IMultihashAlgorithm))]
1992 | [MultihashAlgorithmExport(HashType.SKEIN1024_816, "skein1024-816", 816)]
1993 | public class SKEIN1024_816 : SKEIN
1994 | {
1995 | public SKEIN1024_816()
1996 | : base(HashType.SKEIN1024_816, "skein1024-816", 816, () => new SkeinDigest(1024, 816))
1997 | {
1998 | }
1999 | }
2000 |
2001 | [Export(typeof(IMultihashAlgorithm))]
2002 | [MultihashAlgorithmExport(HashType.SKEIN1024_824, "skein1024-824", 824)]
2003 | public class SKEIN1024_824 : SKEIN
2004 | {
2005 | public SKEIN1024_824()
2006 | : base(HashType.SKEIN1024_824, "skein1024-824", 824, () => new SkeinDigest(1024, 824))
2007 | {
2008 | }
2009 | }
2010 |
2011 | [Export(typeof(IMultihashAlgorithm))]
2012 | [MultihashAlgorithmExport(HashType.SKEIN1024_832, "skein1024-832", 832)]
2013 | public class SKEIN1024_832 : SKEIN
2014 | {
2015 | public SKEIN1024_832()
2016 | : base(HashType.SKEIN1024_832, "skein1024-832", 832, () => new SkeinDigest(1024, 832))
2017 | {
2018 | }
2019 | }
2020 |
2021 | [Export(typeof(IMultihashAlgorithm))]
2022 | [MultihashAlgorithmExport(HashType.SKEIN1024_840, "skein1024-840", 840)]
2023 | public class SKEIN1024_840 : SKEIN
2024 | {
2025 | public SKEIN1024_840()
2026 | : base(HashType.SKEIN1024_840, "skein1024-840", 840, () => new SkeinDigest(1024, 840))
2027 | {
2028 | }
2029 | }
2030 |
2031 | [Export(typeof(IMultihashAlgorithm))]
2032 | [MultihashAlgorithmExport(HashType.SKEIN1024_848, "skein1024-848", 848)]
2033 | public class SKEIN1024_848 : SKEIN
2034 | {
2035 | public SKEIN1024_848()
2036 | : base(HashType.SKEIN1024_848, "skein1024-848", 848, () => new SkeinDigest(1024, 848))
2037 | {
2038 | }
2039 | }
2040 |
2041 | [Export(typeof(IMultihashAlgorithm))]
2042 | [MultihashAlgorithmExport(HashType.SKEIN1024_856, "skein1024-856", 856)]
2043 | public class SKEIN1024_856 : SKEIN
2044 | {
2045 | public SKEIN1024_856()
2046 | : base(HashType.SKEIN1024_856, "skein1024-856", 856, () => new SkeinDigest(1024, 856))
2047 | {
2048 | }
2049 | }
2050 |
2051 | [Export(typeof(IMultihashAlgorithm))]
2052 | [MultihashAlgorithmExport(HashType.SKEIN1024_864, "skein1024-864", 864)]
2053 | public class SKEIN1024_864 : SKEIN
2054 | {
2055 | public SKEIN1024_864()
2056 | : base(HashType.SKEIN1024_864, "skein1024-864", 864, () => new SkeinDigest(1024, 864))
2057 | {
2058 | }
2059 | }
2060 |
2061 | [Export(typeof(IMultihashAlgorithm))]
2062 | [MultihashAlgorithmExport(HashType.SKEIN1024_872, "skein1024-872", 872)]
2063 | public class SKEIN1024_872 : SKEIN
2064 | {
2065 | public SKEIN1024_872()
2066 | : base(HashType.SKEIN1024_872, "skein1024-872", 872, () => new SkeinDigest(1024, 872))
2067 | {
2068 | }
2069 | }
2070 |
2071 | [Export(typeof(IMultihashAlgorithm))]
2072 | [MultihashAlgorithmExport(HashType.SKEIN1024_880, "skein1024-880", 880)]
2073 | public class SKEIN1024_880 : SKEIN
2074 | {
2075 | public SKEIN1024_880()
2076 | : base(HashType.SKEIN1024_880, "skein1024-880", 880, () => new SkeinDigest(1024, 880))
2077 | {
2078 | }
2079 | }
2080 |
2081 | [Export(typeof(IMultihashAlgorithm))]
2082 | [MultihashAlgorithmExport(HashType.SKEIN1024_888, "skein1024-888", 888)]
2083 | public class SKEIN1024_888 : SKEIN
2084 | {
2085 | public SKEIN1024_888()
2086 | : base(HashType.SKEIN1024_888, "skein1024-888", 888, () => new SkeinDigest(1024, 888))
2087 | {
2088 | }
2089 | }
2090 |
2091 | [Export(typeof(IMultihashAlgorithm))]
2092 | [MultihashAlgorithmExport(HashType.SKEIN1024_896, "skein1024-896", 896)]
2093 | public class SKEIN1024_896 : SKEIN
2094 | {
2095 | public SKEIN1024_896()
2096 | : base(HashType.SKEIN1024_896, "skein1024-896", 896, () => new SkeinDigest(1024, 896))
2097 | {
2098 | }
2099 | }
2100 |
2101 | [Export(typeof(IMultihashAlgorithm))]
2102 | [MultihashAlgorithmExport(HashType.SKEIN1024_904, "skein1024-904", 904)]
2103 | public class SKEIN1024_904 : SKEIN
2104 | {
2105 | public SKEIN1024_904()
2106 | : base(HashType.SKEIN1024_904, "skein1024-904", 904, () => new SkeinDigest(1024, 904))
2107 | {
2108 | }
2109 | }
2110 |
2111 | [Export(typeof(IMultihashAlgorithm))]
2112 | [MultihashAlgorithmExport(HashType.SKEIN1024_912, "skein1024-912", 912)]
2113 | public class SKEIN1024_912 : SKEIN
2114 | {
2115 | public SKEIN1024_912()
2116 | : base(HashType.SKEIN1024_912, "skein1024-912", 912, () => new SkeinDigest(1024, 912))
2117 | {
2118 | }
2119 | }
2120 |
2121 | [Export(typeof(IMultihashAlgorithm))]
2122 | [MultihashAlgorithmExport(HashType.SKEIN1024_920, "skein1024-920", 920)]
2123 | public class SKEIN1024_920 : SKEIN
2124 | {
2125 | public SKEIN1024_920()
2126 | : base(HashType.SKEIN1024_920, "skein1024-920", 920, () => new SkeinDigest(1024, 920))
2127 | {
2128 | }
2129 | }
2130 |
2131 | [Export(typeof(IMultihashAlgorithm))]
2132 | [MultihashAlgorithmExport(HashType.SKEIN1024_928, "skein1024-928", 928)]
2133 | public class SKEIN1024_928 : SKEIN
2134 | {
2135 | public SKEIN1024_928()
2136 | : base(HashType.SKEIN1024_928, "skein1024-928", 928, () => new SkeinDigest(1024, 928))
2137 | {
2138 | }
2139 | }
2140 |
2141 | [Export(typeof(IMultihashAlgorithm))]
2142 | [MultihashAlgorithmExport(HashType.SKEIN1024_936, "skein1024-936", 936)]
2143 | public class SKEIN1024_936 : SKEIN
2144 | {
2145 | public SKEIN1024_936()
2146 | : base(HashType.SKEIN1024_936, "skein1024-936", 936, () => new SkeinDigest(1024, 936))
2147 | {
2148 | }
2149 | }
2150 |
2151 | [Export(typeof(IMultihashAlgorithm))]
2152 | [MultihashAlgorithmExport(HashType.SKEIN1024_944, "skein1024-944", 944)]
2153 | public class SKEIN1024_944 : SKEIN
2154 | {
2155 | public SKEIN1024_944()
2156 | : base(HashType.SKEIN1024_944, "skein1024-944", 944, () => new SkeinDigest(1024, 944))
2157 | {
2158 | }
2159 | }
2160 |
2161 | [Export(typeof(IMultihashAlgorithm))]
2162 | [MultihashAlgorithmExport(HashType.SKEIN1024_952, "skein1024-952", 952)]
2163 | public class SKEIN1024_952 : SKEIN
2164 | {
2165 | public SKEIN1024_952()
2166 | : base(HashType.SKEIN1024_952, "skein1024-952", 952, () => new SkeinDigest(1024, 952))
2167 | {
2168 | }
2169 | }
2170 |
2171 | [Export(typeof(IMultihashAlgorithm))]
2172 | [MultihashAlgorithmExport(HashType.SKEIN1024_960, "skein1024-960", 960)]
2173 | public class SKEIN1024_960 : SKEIN
2174 | {
2175 | public SKEIN1024_960()
2176 | : base(HashType.SKEIN1024_960, "skein1024-960", 960, () => new SkeinDigest(1024, 960))
2177 | {
2178 | }
2179 | }
2180 |
2181 | [Export(typeof(IMultihashAlgorithm))]
2182 | [MultihashAlgorithmExport(HashType.SKEIN1024_968, "skein1024-968", 968)]
2183 | public class SKEIN1024_968 : SKEIN
2184 | {
2185 | public SKEIN1024_968()
2186 | : base(HashType.SKEIN1024_968, "skein1024-968", 968, () => new SkeinDigest(1024, 968))
2187 | {
2188 | }
2189 | }
2190 |
2191 | [Export(typeof(IMultihashAlgorithm))]
2192 | [MultihashAlgorithmExport(HashType.SKEIN1024_976, "skein1024-976", 976)]
2193 | public class SKEIN1024_976 : SKEIN
2194 | {
2195 | public SKEIN1024_976()
2196 | : base(HashType.SKEIN1024_976, "skein1024-976", 976, () => new SkeinDigest(1024, 976))
2197 | {
2198 | }
2199 | }
2200 |
2201 | [Export(typeof(IMultihashAlgorithm))]
2202 | [MultihashAlgorithmExport(HashType.SKEIN1024_984, "skein1024-984", 984)]
2203 | public class SKEIN1024_984 : SKEIN
2204 | {
2205 | public SKEIN1024_984()
2206 | : base(HashType.SKEIN1024_984, "skein1024-984", 984, () => new SkeinDigest(1024, 984))
2207 | {
2208 | }
2209 | }
2210 |
2211 | [Export(typeof(IMultihashAlgorithm))]
2212 | [MultihashAlgorithmExport(HashType.SKEIN1024_992, "skein1024-992", 992)]
2213 | public class SKEIN1024_992 : SKEIN
2214 | {
2215 | public SKEIN1024_992()
2216 | : base(HashType.SKEIN1024_992, "skein1024-992", 992, () => new SkeinDigest(1024, 992))
2217 | {
2218 | }
2219 | }
2220 |
2221 | [Export(typeof(IMultihashAlgorithm))]
2222 | [MultihashAlgorithmExport(HashType.SKEIN1024_1000, "skein1024-1000", 1000)]
2223 | public class SKEIN1024_1000 : SKEIN
2224 | {
2225 | public SKEIN1024_1000()
2226 | : base(HashType.SKEIN1024_1000, "skein1024-1000", 1000, () => new SkeinDigest(1024, 1000))
2227 | {
2228 | }
2229 | }
2230 |
2231 | [Export(typeof(IMultihashAlgorithm))]
2232 | [MultihashAlgorithmExport(HashType.SKEIN1024_1008, "skein1024-1008", 1008)]
2233 | public class SKEIN1024_1008 : SKEIN
2234 | {
2235 | public SKEIN1024_1008()
2236 | : base(HashType.SKEIN1024_1008, "skein1024-1008", 1008, () => new SkeinDigest(1024, 1008))
2237 | {
2238 | }
2239 | }
2240 |
2241 | [Export(typeof(IMultihashAlgorithm))]
2242 | [MultihashAlgorithmExport(HashType.SKEIN1024_1016, "skein1024-1016", 1016)]
2243 | public class SKEIN1024_1016 : SKEIN
2244 | {
2245 | public SKEIN1024_1016()
2246 | : base(HashType.SKEIN1024_1016, "skein1024-1016", 1016, () => new SkeinDigest(1024, 1016))
2247 | {
2248 | }
2249 | }
2250 |
2251 | [Export(typeof(IMultihashAlgorithm))]
2252 | [MultihashAlgorithmExport(HashType.SKEIN1024_1024, "skein1024-1024", 1024)]
2253 | public class SKEIN1024_1024 : SKEIN
2254 | {
2255 | public SKEIN1024_1024()
2256 | : base(HashType.SKEIN1024_1024, "skein1024-1024", 1024, () => new SkeinDigest(1024, 1024))
2257 | {
2258 | }
2259 | }
2260 | }
2261 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Algorithms/SKEIN.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | using System;
8 | using System.Composition;
9 | using Org.BouncyCastle.Crypto;
10 | using Org.BouncyCastle.Crypto.Digests;
11 |
12 | namespace Multiformats.Hash.Algorithms
13 | {
14 | public abstract class SKEIN : MultihashAlgorithm
15 | {
16 | private readonly Func _factory;
17 |
18 | protected SKEIN(HashType code, string name, int defaultLength, Func factory)
19 | : base(code, name, defaultLength)
20 | {
21 | _factory = factory;
22 | }
23 |
24 | public override byte[] ComputeHash(byte[] data, int length = -1) => _factory().ComputeHash(data);
25 | }
26 | <#
27 | for (int bits = 256; bits <= 1024; bits *= 2)
28 | {
29 | for (int length = 8; length <= bits; length += 8)
30 | {
31 | #>
32 |
33 | [Export(typeof(IMultihashAlgorithm))]
34 | [MultihashAlgorithmExport(HashType.SKEIN<#= bits #>_<#= length #>, "skein<#= bits #>-<#= length #>", <#= length #>)]
35 | public class SKEIN<#= bits #>_<#= length #> : SKEIN
36 | {
37 | public SKEIN<#= bits #>_<#= length #>()
38 | : base(HashType.SKEIN<#= bits #>_<#= length #>, "skein<#= bits #>-<#= length #>", <#= length #>, () => new SkeinDigest(<#= bits #>, <#= length #>))
39 | {
40 | }
41 | }
42 | <#
43 | }
44 | }
45 | #>
46 | }
47 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Extensions.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.IO;
3 | using System.Linq;
4 | using System.Threading;
5 | using System.Threading.Tasks;
6 | using BinaryEncoding;
7 |
8 | namespace Multiformats.Hash
9 | {
10 | public static class Extensions
11 | {
12 | public static Multihash ReadMultihash(this Stream stream)
13 | {
14 | if (Binary.Varint.Read(stream, out uint code) <= 0)
15 | return null;
16 |
17 | if (Binary.Varint.Read(stream, out uint length) <= 0)
18 | return null;
19 |
20 | var buffer = new byte[length];
21 | if (stream.Read(buffer, 0, buffer.Length) != length)
22 | return null;
23 |
24 | return Multihash.Cast(Binary.Varint.GetBytes(code).Concat(Binary.Varint.GetBytes(length), buffer));
25 | }
26 |
27 | public static async Task ReadMultihashAsync(this Stream stream, CancellationToken cancellationToken)
28 | {
29 | var code = await Binary.Varint.ReadUInt32Async(stream);
30 | // @Todo: we should check how many bytes we have read,
31 | // but the method we're using doesn't support that.
32 |
33 | var length = await Binary.Varint.ReadUInt32Async(stream);
34 | if (length == 0)
35 | return null;
36 |
37 | var buffer = new byte[length];
38 | if (await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken) != length)
39 | return null;
40 |
41 | return Multihash.Cast(Binary.Varint.GetBytes(code).Concat(Binary.Varint.GetBytes(length), buffer));
42 | }
43 |
44 | public static void Write(this Stream stream, Multihash mh)
45 | {
46 | var bytes = mh.ToBytes();
47 | stream.Write(bytes, 0, bytes.Length);
48 | }
49 |
50 | public static Task WriteAsync(this Stream stream, Multihash mh, CancellationToken cancellationToken)
51 | {
52 | var bytes = mh.ToBytes();
53 | return stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken);
54 | }
55 |
56 | internal static byte[] Slice(this byte[] buffer, int offset = 0, int? count = null)
57 | {
58 | var result = new byte[Math.Min(count ?? buffer.Length - offset, buffer.Length - offset)];
59 | Buffer.BlockCopy(buffer, offset, result, 0, result.Length);
60 | return result;
61 | }
62 |
63 | internal static byte[] Concat(this byte[] buffer, params byte[][] buffers)
64 | {
65 | var result = new byte[buffer.Length + buffers.Sum(b => b.Length)];
66 | Buffer.BlockCopy(buffer, 0, result, 0, buffer.Length);
67 | var offset = buffer.Length;
68 | foreach (var buf in buffers)
69 | {
70 | Buffer.BlockCopy(buf, 0, result, offset, buf.Length);
71 | offset += buf.Length;
72 | }
73 | return result;
74 | }
75 | }
76 | }
77 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/HashType.cs:
--------------------------------------------------------------------------------
1 | namespace Multiformats.Hash
2 | {
3 | public enum HashType : uint
4 | {
5 | ID = 0x00,
6 | MD4 = 0xd4,
7 | MD5 = 0xd5,
8 | SHA1 = 0x11,
9 | SHA2_256 = 0x12,
10 | SHA2_512 = 0x13,
11 | SHA3_512 = 0x14,
12 | SHA3_384 = 0x15,
13 | SHA3_256 = 0x16,
14 | SHA3_224 = 0x17,
15 | SHAKE_128 = 0x18,
16 | SHAKE_256 = 0x19,
17 | KECCAK_224 = 0x1A,
18 | KECCAK_256 = 0x1B,
19 | KECCAK_384 = 0x1C,
20 | KECCAK_512 = 0x1D,
21 | MURMUR3_128 = 0x23,
22 | MURMUR3_32 = 0x22,
23 | BLAKE2B_8 = 0xb201,
24 | BLAKE2B_16 = 0xb202,
25 | BLAKE2B_24 = 0xb203,
26 | BLAKE2B_32 = 0xb204,
27 | BLAKE2B_40 = 0xb205,
28 | BLAKE2B_48 = 0xb206,
29 | BLAKE2B_56 = 0xb207,
30 | BLAKE2B_64 = 0xb208,
31 | BLAKE2B_72 = 0xb209,
32 | BLAKE2B_80 = 0xb20a,
33 | BLAKE2B_88 = 0xb20b,
34 | BLAKE2B_96 = 0xb20c,
35 | BLAKE2B_104 = 0xb20d,
36 | BLAKE2B_112 = 0xb20e,
37 | BLAKE2B_120 = 0xb20f,
38 | BLAKE2B_128 = 0xb210,
39 | BLAKE2B_136 = 0xb211,
40 | BLAKE2B_144 = 0xb212,
41 | BLAKE2B_152 = 0xb213,
42 | BLAKE2B_160 = 0xb214,
43 | BLAKE2B_168 = 0xb215,
44 | BLAKE2B_176 = 0xb216,
45 | BLAKE2B_184 = 0xb217,
46 | BLAKE2B_192 = 0xb218,
47 | BLAKE2B_200 = 0xb219,
48 | BLAKE2B_208 = 0xb21a,
49 | BLAKE2B_216 = 0xb21b,
50 | BLAKE2B_224 = 0xb21c,
51 | BLAKE2B_232 = 0xb21d,
52 | BLAKE2B_240 = 0xb21e,
53 | BLAKE2B_248 = 0xb21f,
54 | BLAKE2B_256 = 0xb220,
55 | BLAKE2B_264 = 0xb221,
56 | BLAKE2B_272 = 0xb222,
57 | BLAKE2B_280 = 0xb223,
58 | BLAKE2B_288 = 0xb224,
59 | BLAKE2B_296 = 0xb225,
60 | BLAKE2B_304 = 0xb226,
61 | BLAKE2B_312 = 0xb227,
62 | BLAKE2B_320 = 0xb228,
63 | BLAKE2B_328 = 0xb229,
64 | BLAKE2B_336 = 0xb22a,
65 | BLAKE2B_344 = 0xb22b,
66 | BLAKE2B_352 = 0xb22c,
67 | BLAKE2B_360 = 0xb22d,
68 | BLAKE2B_368 = 0xb22e,
69 | BLAKE2B_376 = 0xb22f,
70 | BLAKE2B_384 = 0xb230,
71 | BLAKE2B_392 = 0xb231,
72 | BLAKE2B_400 = 0xb232,
73 | BLAKE2B_408 = 0xb233,
74 | BLAKE2B_416 = 0xb234,
75 | BLAKE2B_424 = 0xb235,
76 | BLAKE2B_432 = 0xb236,
77 | BLAKE2B_440 = 0xb237,
78 | BLAKE2B_448 = 0xb238,
79 | BLAKE2B_456 = 0xb239,
80 | BLAKE2B_464 = 0xb23a,
81 | BLAKE2B_472 = 0xb23b,
82 | BLAKE2B_480 = 0xb23c,
83 | BLAKE2B_488 = 0xb23d,
84 | BLAKE2B_496 = 0xb23e,
85 | BLAKE2B_504 = 0xb23f,
86 | BLAKE2B_512 = 0xb240,
87 | BLAKE2S_8 = 0xb241,
88 | BLAKE2S_16 = 0xb242,
89 | BLAKE2S_24 = 0xb243,
90 | BLAKE2S_32 = 0xb244,
91 | BLAKE2S_40 = 0xb245,
92 | BLAKE2S_48 = 0xb246,
93 | BLAKE2S_56 = 0xb247,
94 | BLAKE2S_64 = 0xb248,
95 | BLAKE2S_72 = 0xb249,
96 | BLAKE2S_80 = 0xb24a,
97 | BLAKE2S_88 = 0xb24b,
98 | BLAKE2S_96 = 0xb24c,
99 | BLAKE2S_104 = 0xb24d,
100 | BLAKE2S_112 = 0xb24e,
101 | BLAKE2S_120 = 0xb24f,
102 | BLAKE2S_128 = 0xb250,
103 | BLAKE2S_136 = 0xb251,
104 | BLAKE2S_144 = 0xb252,
105 | BLAKE2S_152 = 0xb253,
106 | BLAKE2S_160 = 0xb254,
107 | BLAKE2S_168 = 0xb255,
108 | BLAKE2S_176 = 0xb256,
109 | BLAKE2S_184 = 0xb257,
110 | BLAKE2S_192 = 0xb258,
111 | BLAKE2S_200 = 0xb259,
112 | BLAKE2S_208 = 0xb25a,
113 | BLAKE2S_216 = 0xb25b,
114 | BLAKE2S_224 = 0xb25c,
115 | BLAKE2S_232 = 0xb25d,
116 | BLAKE2S_240 = 0xb25e,
117 | BLAKE2S_248 = 0xb25f,
118 | BLAKE2S_256 = 0xb260,
119 | SKEIN256_8 = 0xb301,
120 | SKEIN256_16 = 0xb302,
121 | SKEIN256_24 = 0xb303,
122 | SKEIN256_32 = 0xb304,
123 | SKEIN256_40 = 0xb305,
124 | SKEIN256_48 = 0xb306,
125 | SKEIN256_56 = 0xb307,
126 | SKEIN256_64 = 0xb308,
127 | SKEIN256_72 = 0xb309,
128 | SKEIN256_80 = 0xb30a,
129 | SKEIN256_88 = 0xb30b,
130 | SKEIN256_96 = 0xb30c,
131 | SKEIN256_104 = 0xb30d,
132 | SKEIN256_112 = 0xb30e,
133 | SKEIN256_120 = 0xb30f,
134 | SKEIN256_128 = 0xb310,
135 | SKEIN256_136 = 0xb311,
136 | SKEIN256_144 = 0xb312,
137 | SKEIN256_152 = 0xb313,
138 | SKEIN256_160 = 0xb314,
139 | SKEIN256_168 = 0xb315,
140 | SKEIN256_176 = 0xb316,
141 | SKEIN256_184 = 0xb317,
142 | SKEIN256_192 = 0xb318,
143 | SKEIN256_200 = 0xb319,
144 | SKEIN256_208 = 0xb31a,
145 | SKEIN256_216 = 0xb31b,
146 | SKEIN256_224 = 0xb31c,
147 | SKEIN256_232 = 0xb31d,
148 | SKEIN256_240 = 0xb31e,
149 | SKEIN256_248 = 0xb31f,
150 | SKEIN256_256 = 0xb320,
151 | SKEIN512_8 = 0xb321,
152 | SKEIN512_16 = 0xb322,
153 | SKEIN512_24 = 0xb323,
154 | SKEIN512_32 = 0xb324,
155 | SKEIN512_40 = 0xb325,
156 | SKEIN512_48 = 0xb326,
157 | SKEIN512_56 = 0xb327,
158 | SKEIN512_64 = 0xb328,
159 | SKEIN512_72 = 0xb329,
160 | SKEIN512_80 = 0xb32a,
161 | SKEIN512_88 = 0xb32b,
162 | SKEIN512_96 = 0xb32c,
163 | SKEIN512_104 = 0xb32d,
164 | SKEIN512_112 = 0xb32e,
165 | SKEIN512_120 = 0xb32f,
166 | SKEIN512_128 = 0xb330,
167 | SKEIN512_136 = 0xb331,
168 | SKEIN512_144 = 0xb332,
169 | SKEIN512_152 = 0xb333,
170 | SKEIN512_160 = 0xb334,
171 | SKEIN512_168 = 0xb335,
172 | SKEIN512_176 = 0xb336,
173 | SKEIN512_184 = 0xb337,
174 | SKEIN512_192 = 0xb338,
175 | SKEIN512_200 = 0xb339,
176 | SKEIN512_208 = 0xb33a,
177 | SKEIN512_216 = 0xb33b,
178 | SKEIN512_224 = 0xb33c,
179 | SKEIN512_232 = 0xb33d,
180 | SKEIN512_240 = 0xb33e,
181 | SKEIN512_248 = 0xb33f,
182 | SKEIN512_256 = 0xb340,
183 | SKEIN512_264 = 0xb341,
184 | SKEIN512_272 = 0xb342,
185 | SKEIN512_280 = 0xb343,
186 | SKEIN512_288 = 0xb344,
187 | SKEIN512_296 = 0xb345,
188 | SKEIN512_304 = 0xb346,
189 | SKEIN512_312 = 0xb347,
190 | SKEIN512_320 = 0xb348,
191 | SKEIN512_328 = 0xb349,
192 | SKEIN512_336 = 0xb34a,
193 | SKEIN512_344 = 0xb34b,
194 | SKEIN512_352 = 0xb34c,
195 | SKEIN512_360 = 0xb34d,
196 | SKEIN512_368 = 0xb34e,
197 | SKEIN512_376 = 0xb34f,
198 | SKEIN512_384 = 0xb350,
199 | SKEIN512_392 = 0xb351,
200 | SKEIN512_400 = 0xb352,
201 | SKEIN512_408 = 0xb353,
202 | SKEIN512_416 = 0xb354,
203 | SKEIN512_424 = 0xb355,
204 | SKEIN512_432 = 0xb356,
205 | SKEIN512_440 = 0xb357,
206 | SKEIN512_448 = 0xb358,
207 | SKEIN512_456 = 0xb359,
208 | SKEIN512_464 = 0xb35a,
209 | SKEIN512_472 = 0xb35b,
210 | SKEIN512_480 = 0xb35c,
211 | SKEIN512_488 = 0xb35d,
212 | SKEIN512_496 = 0xb35e,
213 | SKEIN512_504 = 0xb35f,
214 | SKEIN512_512 = 0xb360,
215 | SKEIN1024_8 = 0xb361,
216 | SKEIN1024_16 = 0xb362,
217 | SKEIN1024_24 = 0xb363,
218 | SKEIN1024_32 = 0xb364,
219 | SKEIN1024_40 = 0xb365,
220 | SKEIN1024_48 = 0xb366,
221 | SKEIN1024_56 = 0xb367,
222 | SKEIN1024_64 = 0xb368,
223 | SKEIN1024_72 = 0xb369,
224 | SKEIN1024_80 = 0xb36a,
225 | SKEIN1024_88 = 0xb36b,
226 | SKEIN1024_96 = 0xb36c,
227 | SKEIN1024_104 = 0xb36d,
228 | SKEIN1024_112 = 0xb36e,
229 | SKEIN1024_120 = 0xb36f,
230 | SKEIN1024_128 = 0xb370,
231 | SKEIN1024_136 = 0xb371,
232 | SKEIN1024_144 = 0xb372,
233 | SKEIN1024_152 = 0xb373,
234 | SKEIN1024_160 = 0xb374,
235 | SKEIN1024_168 = 0xb375,
236 | SKEIN1024_176 = 0xb376,
237 | SKEIN1024_184 = 0xb377,
238 | SKEIN1024_192 = 0xb378,
239 | SKEIN1024_200 = 0xb379,
240 | SKEIN1024_208 = 0xb37a,
241 | SKEIN1024_216 = 0xb37b,
242 | SKEIN1024_224 = 0xb37c,
243 | SKEIN1024_232 = 0xb37d,
244 | SKEIN1024_240 = 0xb37e,
245 | SKEIN1024_248 = 0xb37f,
246 | SKEIN1024_256 = 0xb380,
247 | SKEIN1024_264 = 0xb381,
248 | SKEIN1024_272 = 0xb382,
249 | SKEIN1024_280 = 0xb383,
250 | SKEIN1024_288 = 0xb384,
251 | SKEIN1024_296 = 0xb385,
252 | SKEIN1024_304 = 0xb386,
253 | SKEIN1024_312 = 0xb387,
254 | SKEIN1024_320 = 0xb388,
255 | SKEIN1024_328 = 0xb389,
256 | SKEIN1024_336 = 0xb38a,
257 | SKEIN1024_344 = 0xb38b,
258 | SKEIN1024_352 = 0xb38c,
259 | SKEIN1024_360 = 0xb38d,
260 | SKEIN1024_368 = 0xb38e,
261 | SKEIN1024_376 = 0xb38f,
262 | SKEIN1024_384 = 0xb390,
263 | SKEIN1024_392 = 0xb391,
264 | SKEIN1024_400 = 0xb392,
265 | SKEIN1024_408 = 0xb393,
266 | SKEIN1024_416 = 0xb394,
267 | SKEIN1024_424 = 0xb395,
268 | SKEIN1024_432 = 0xb396,
269 | SKEIN1024_440 = 0xb397,
270 | SKEIN1024_448 = 0xb398,
271 | SKEIN1024_456 = 0xb399,
272 | SKEIN1024_464 = 0xb39a,
273 | SKEIN1024_472 = 0xb39b,
274 | SKEIN1024_480 = 0xb39c,
275 | SKEIN1024_488 = 0xb39d,
276 | SKEIN1024_496 = 0xb39e,
277 | SKEIN1024_504 = 0xb39f,
278 | SKEIN1024_512 = 0xb3a0,
279 | SKEIN1024_520 = 0xb3a1,
280 | SKEIN1024_528 = 0xb3a2,
281 | SKEIN1024_536 = 0xb3a3,
282 | SKEIN1024_544 = 0xb3a4,
283 | SKEIN1024_552 = 0xb3a5,
284 | SKEIN1024_560 = 0xb3a6,
285 | SKEIN1024_568 = 0xb3a7,
286 | SKEIN1024_576 = 0xb3a8,
287 | SKEIN1024_584 = 0xb3a9,
288 | SKEIN1024_592 = 0xb3aa,
289 | SKEIN1024_600 = 0xb3ab,
290 | SKEIN1024_608 = 0xb3ac,
291 | SKEIN1024_616 = 0xb3ad,
292 | SKEIN1024_624 = 0xb3ae,
293 | SKEIN1024_632 = 0xb3af,
294 | SKEIN1024_640 = 0xb3b0,
295 | SKEIN1024_648 = 0xb3b1,
296 | SKEIN1024_656 = 0xb3b2,
297 | SKEIN1024_664 = 0xb3b3,
298 | SKEIN1024_672 = 0xb3b4,
299 | SKEIN1024_680 = 0xb3b5,
300 | SKEIN1024_688 = 0xb3b6,
301 | SKEIN1024_696 = 0xb3b7,
302 | SKEIN1024_704 = 0xb3b8,
303 | SKEIN1024_712 = 0xb3b9,
304 | SKEIN1024_720 = 0xb3ba,
305 | SKEIN1024_728 = 0xb3bb,
306 | SKEIN1024_736 = 0xb3bc,
307 | SKEIN1024_744 = 0xb3bd,
308 | SKEIN1024_752 = 0xb3be,
309 | SKEIN1024_760 = 0xb3bf,
310 | SKEIN1024_768 = 0xb3c0,
311 | SKEIN1024_776 = 0xb3c1,
312 | SKEIN1024_784 = 0xb3c2,
313 | SKEIN1024_792 = 0xb3c3,
314 | SKEIN1024_800 = 0xb3c4,
315 | SKEIN1024_808 = 0xb3c5,
316 | SKEIN1024_816 = 0xb3c6,
317 | SKEIN1024_824 = 0xb3c7,
318 | SKEIN1024_832 = 0xb3c8,
319 | SKEIN1024_840 = 0xb3c9,
320 | SKEIN1024_848 = 0xb3ca,
321 | SKEIN1024_856 = 0xb3cb,
322 | SKEIN1024_864 = 0xb3cc,
323 | SKEIN1024_872 = 0xb3cd,
324 | SKEIN1024_880 = 0xb3ce,
325 | SKEIN1024_888 = 0xb3cf,
326 | SKEIN1024_896 = 0xb3d0,
327 | SKEIN1024_904 = 0xb3d1,
328 | SKEIN1024_912 = 0xb3d2,
329 | SKEIN1024_920 = 0xb3d3,
330 | SKEIN1024_928 = 0xb3d4,
331 | SKEIN1024_936 = 0xb3d5,
332 | SKEIN1024_944 = 0xb3d6,
333 | SKEIN1024_952 = 0xb3d7,
334 | SKEIN1024_960 = 0xb3d8,
335 | SKEIN1024_968 = 0xb3d9,
336 | SKEIN1024_976 = 0xb3da,
337 | SKEIN1024_984 = 0xb3db,
338 | SKEIN1024_992 = 0xb3dc,
339 | SKEIN1024_1000 = 0xb3dd,
340 | SKEIN1024_1008 = 0xb3de,
341 | SKEIN1024_1016 = 0xb3df,
342 | SKEIN1024_1024 = 0xb3e0,
343 | DBL_SHA2_256 = 0x56
344 | }
345 | }
346 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/HashType.tt:
--------------------------------------------------------------------------------
1 | <#@ template debug="false" hostspecific="false" language="C#" #>
2 | <#@ assembly name="System.Core" #>
3 | <#@ import namespace="System.Linq" #>
4 | <#@ import namespace="System.Text" #>
5 | <#@ import namespace="System.Collections.Generic" #>
6 | <#@ output extension=".cs" #>
7 | namespace Multiformats.Hash
8 | {
9 | public enum HashType : uint
10 | {
11 | ID = 0x00,
12 | MD4 = 0xd4,
13 | MD5 = 0xd5,
14 | SHA1 = 0x11,
15 | SHA2_256 = 0x12,
16 | SHA2_512 = 0x13,
17 | SHA3_512 = 0x14,
18 | SHA3_384 = 0x15,
19 | SHA3_256 = 0x16,
20 | SHA3_224 = 0x17,
21 | SHAKE_128 = 0x18,
22 | SHAKE_256 = 0x19,
23 | <#
24 | var keccac_bits = new int[] { 224, 256, 384, 512 };
25 | for (var i = 0; i < keccac_bits.Length; i++)
26 | {
27 | #>
28 | KECCAK_<#= keccac_bits[i] #> = <#= string.Format("0x{0:X}", 26 + i) #>,
29 | <#
30 | }
31 | #>
32 | MURMUR3_128 = 0x23,
33 | MURMUR3_32 = 0x22,
34 | <#
35 | for (int i = 8; i <= 512; i += 8)
36 | {
37 | #>
38 | BLAKE2B_<#= i #> = <#= string.Format("0x{0:x}", 45569 + (i / 8) - 1) #>,
39 | <#
40 | }
41 |
42 | for (int i = 8; i <= 256; i += 8) { #>
43 | BLAKE2S_<#= i #> = <#= string.Format("0x{0:x}", 45633 + (i / 8) - 1) #>,
44 | <#
45 | }
46 |
47 | var skeinIndex = 0;
48 | for (int bits = 256; bits <= 1024; bits *= 2)
49 | {
50 | for (int length = 8; length <= bits; length += 8)
51 | {
52 | #>
53 | SKEIN<#= bits #>_<#= length #> = <#= string.Format("0x{0:x}", 45825 + skeinIndex++) #>,
54 | <#
55 | }
56 | }
57 | #>
58 | DBL_SHA2_256 = 0x56
59 | }
60 | }
61 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Multiformats.Hash.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 | netstandard1.6;netstandard2.0;net461
4 | win10-x64;osx-x64;ubuntu-x64
5 | Multiformat hash encoding
6 | Copyright © tabrath 2019
7 | Multiformats.Hash
8 | 1.5.0
9 | tabrath
10 | true
11 | Multiformats.Hash
12 | Multiformats.Hash
13 | multiformats multihash sha1 sha3 keccak blake2 shake
14 | https://cdn.rawgit.com/multiformats/website/116894f6/favicon.png
15 | https://github.com/multiformats/cs-multihash/blob/master/LICENSE
16 | git
17 | https://github.com/multiformats/cs-multihash
18 | AnyCPU
19 | Library
20 | true
21 |
22 | $(NoWarn);NU1605
23 |
24 |
25 | true
26 | portable
27 | false
28 | $(DefineConstants);DEBUG
29 |
30 |
31 | portable
32 | true
33 | $(DefineConstants)
34 |
35 |
36 |
37 | true
38 |
39 | false
40 |
41 | true
42 | snupkg
43 | .pdb;$(AllowedOutputExtensionsInPackageBuildOutputFolder)
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 | all
53 |
54 |
55 |
56 |
57 | BLAKE2B.tt
58 | True
59 | True
60 |
61 |
62 | BLAKE2S.tt
63 | True
64 | True
65 |
66 |
67 | KECCAK.tt
68 | True
69 | True
70 |
71 |
72 | SHA2.tt
73 | True
74 | True
75 |
76 |
77 | SHA3.tt
78 | True
79 | True
80 |
81 |
82 | SHAKE.tt
83 | True
84 | True
85 |
86 |
87 | SKEIN.tt
88 | True
89 | True
90 |
91 |
92 | True
93 | True
94 | HashType.tt
95 |
96 |
97 |
98 |
99 | TextTemplatingFileGenerator
100 | BLAKE2B.cs
101 |
102 |
103 | TextTemplatingFileGenerator
104 | BLAKE2S.cs
105 |
106 |
107 | TextTemplatingFileGenerator
108 | KECCAK.cs
109 |
110 |
111 | TextTemplatingFileGenerator
112 | SHA2.cs
113 |
114 |
115 | TextTemplatingFileGenerator
116 | SHA3.cs
117 |
118 |
119 | SKEIN.cs
120 | TextTemplatingFileGenerator
121 |
122 |
123 | TextTemplatingFileGenerator
124 | SHAKE.cs
125 |
126 |
127 | TextTemplatingFileGenerator
128 | HashType.cs
129 |
130 |
131 |
132 |
133 |
134 |
135 |
--------------------------------------------------------------------------------
/src/Multiformats.Hash/Multihash.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Linq;
3 | using System.Threading.Tasks;
4 | using BinaryEncoding;
5 | using Multiformats.Base;
6 | using Multiformats.Hash.Algorithms;
7 |
8 | namespace Multiformats.Hash
9 | {
10 | public class Multihash
11 | {
12 | private static readonly Registry _registry = new Registry();
13 |
14 | public HashType Code { get; }
15 | public string Name { get; }
16 | public int Length => Digest?.Length ?? 0;
17 | public byte[] Digest { get; }
18 |
19 | public static HashType[] SupportedHashCodes => _registry.SupportedHashTypes;
20 |
21 | private readonly Lazy _bytes;
22 |
23 | protected Multihash(byte[] bytes)
24 | {
25 | _bytes = new Lazy(() => bytes);
26 | }
27 |
28 | protected Multihash(HashType code, byte[] digest)
29 | {
30 | Code = code;
31 | Name = GetName((int) code);
32 | Digest = digest;
33 |
34 | _bytes = new Lazy(() => Encode(digest, code));
35 | }
36 |
37 | public string ToString(MultibaseEncoding encoding) => Multibase.EncodeRaw(encoding, _bytes.Value);
38 | public override string ToString() => ToString(MultibaseEncoding.Base16Lower);
39 |
40 | [Obsolete("Use ToString() instead")]
41 | public string B58String() => ToString(MultibaseEncoding.Base58Btc);
42 |
43 | [Obsolete("Use ToString() instead")]
44 | public string ToHexString() => ToString(MultibaseEncoding.Base16Lower);
45 |
46 | public byte[] ToBytes() => _bytes.Value;
47 |
48 | public override bool Equals(object obj)
49 | {
50 | var other = (Multihash) obj;
51 | return other != null && _bytes.Value.SequenceEqual(other._bytes.Value);
52 | }
53 |
54 | public override int GetHashCode() => (int) Code ^ Length ^ Digest.Sum(b => b);
55 |
56 | public bool Verify(byte[] data) => Sum(Code, data, Length).Equals(this);
57 | public Task VerifyAsync(byte[] data) => SumAsync(Code, data, Length).ContinueWith(mh => mh.Result?.Equals(this) ?? false);
58 |
59 | private static readonly MultibaseEncoding[] _encodings =
60 | {
61 | MultibaseEncoding.Base16Lower,
62 | MultibaseEncoding.Base32Lower,
63 | MultibaseEncoding.Base58Btc,
64 | MultibaseEncoding.Base64,
65 | MultibaseEncoding.Base2,
66 | MultibaseEncoding.Base8,
67 | };
68 |
69 | public static bool TryParse(string s, out Multihash mh, out MultibaseEncoding encoding)
70 | {
71 | foreach (var _encoding in _encodings)
72 | {
73 | try
74 | {
75 | encoding = _encoding;
76 | if (TryParse(s, encoding, out mh))
77 | {
78 | return true;
79 | }
80 | }
81 | catch (Exception) { }
82 | }
83 |
84 | mh = null;
85 | encoding = (MultibaseEncoding)(-1);
86 | return false;
87 | }
88 |
89 | public static bool TryParse(string s, out Multihash mh)
90 | {
91 | return TryParse(s, out mh, out _);
92 | }
93 |
94 | public static Multihash Parse(string s)
95 | {
96 | if (!TryParse(s, out var mh))
97 | throw new FormatException("Not a valid multihash");
98 |
99 | return mh;
100 | }
101 |
102 | public static bool TryParse(string s, MultibaseEncoding encoding, out Multihash mh)
103 | {
104 | try
105 | {
106 | var bytes = Multibase.DecodeRaw(encoding, s);
107 | mh = Decode(bytes);
108 | return true;
109 | }
110 | catch (Exception) { }
111 |
112 | mh = null;
113 | return false;
114 | }
115 |
116 | public static Multihash Parse(string s, MultibaseEncoding encoding)
117 | {
118 | if (!TryParse(s, encoding, out var mh))
119 | throw new FormatException("Not a valid multihash");
120 |
121 | return mh;
122 | }
123 |
124 | [Obsolete("Use Parse/TryParse instead")]
125 | public static Multihash FromHexString(string s) => Cast(Multibase.Base16.Decode(s));
126 |
127 | [Obsolete("Use Parse/TryParse instead")]
128 | public static Multihash FromB58String(string s) => Cast(Multibase.Base58.Decode(s));
129 |
130 | public static Multihash Cast(byte[] buf) => Decode(buf);
131 |
132 | public static Multihash Decode(byte[] buf)
133 | {
134 | if (buf == null)
135 | throw new ArgumentNullException(nameof(buf));
136 |
137 | if (buf.Length < 2)
138 | throw new Exception("Too short");
139 |
140 | var offset = Binary.Varint.Read(buf, 0, out uint code);
141 | offset += Binary.Varint.Read(buf, offset, out uint length);
142 |
143 | if (length > buf.Length - offset)
144 | throw new Exception("Incosistent length");
145 |
146 | return new Multihash((HashType)code, buf.Slice(offset));
147 | }
148 |
149 | public static byte[] Encode(byte[] data, HashType code) => Binary.Varint.GetBytes((uint) code).Concat(Binary.Varint.GetBytes((uint)data.Length), data);
150 | public static Multihash Encode(string s, HashType code) => Encode(Multibase.Base32.Decode(s), code);
151 | public static byte[] Encode(byte[] data) where TAlgorithm : IMultihashAlgorithm
152 | {
153 | var algo = Registry.GetHashType();
154 | if (!algo.HasValue)
155 | throw new NotSupportedException($"{typeof(TAlgorithm)} is not supported.");
156 |
157 | return Binary.Varint.GetBytes((uint)algo.Value).Concat(Binary.Varint.GetBytes((uint)data.Length), data);
158 | }
159 |
160 | private static Multihash Sum(IMultihashAlgorithm algo, byte[] data, int length) => new Multihash(algo.Code, algo.ComputeHash(data, length).Slice(0, length != -1 ? length : algo.DefaultLength));
161 | public static Multihash Sum(HashType code, byte[] data, int length = -1) => _registry.Use(code, algo => Sum(algo, data, length));
162 | public static Multihash Sum(byte[] data, int length = -1) where TAlgorithm : IMultihashAlgorithm => _registry.Use(algo => Sum(algo, data, length));
163 | private static Task SumAsync(IMultihashAlgorithm algo, byte[] data, int length) => algo.ComputeHashAsync(data, length).ContinueWith(t => new Multihash(algo.Code, t.Result.Slice(0, length != -1 ? length : algo.DefaultLength)));
164 | public static Task SumAsync(HashType type, byte[] data, int length = -1) => _registry.UseAsync(type, algo => SumAsync(algo, data, length));
165 | public static Task SumAsync(byte[] data, int length = -1) where TAlgorithm : IMultihashAlgorithm => _registry.UseAsync(algo => SumAsync(algo, data, length));
166 |
167 | public static implicit operator Multihash(byte[] buf) => Decode(buf);
168 | public static implicit operator byte[](Multihash mh) => mh._bytes.Value;
169 | public static implicit operator Multihash(string s) => Parse(s);
170 | public static implicit operator string(Multihash mh) => mh.ToString(MultibaseEncoding.Base16Lower);
171 |
172 | public static string GetName(HashType code) => code.ToString().Replace("_", "-").ToLower();
173 | public static string GetName(int code) => Enum.IsDefined(typeof(HashType), (HashType)code) ? GetName((HashType)code) : "unsupported";
174 |
175 | public static HashType? GetCode(string name) => Enum.TryParse(name.Replace("-", "_"), true, out HashType result) ? result : new HashType?();
176 | }
177 | }
178 |
--------------------------------------------------------------------------------
/test/Multiformats.Hash.Tests/ExtensionTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.IO;
3 | using System.Linq;
4 | using System.Text;
5 | using System.Threading;
6 | using System.Threading.Tasks;
7 | using Xunit;
8 |
9 | namespace Multiformats.Hash.Tests
10 | {
11 | public class ExtensionTests
12 | {
13 | public HashType[] SupportedHashTypes { get; }
14 |
15 | public ExtensionTests()
16 | {
17 | SupportedHashTypes = Enum.GetValues(typeof(HashType)).Cast().ToArray();
18 | }
19 |
20 | [Fact]
21 | public void Read_StreamGivenMultistreamContent_ReturnsValidMultihashes()
22 | {
23 | var data = Encoding.UTF8.GetBytes("hello world");
24 | var hashes = SupportedHashTypes.Select(type => Multihash.Sum(type, data)).ToArray();
25 |
26 | using (var stream = new MemoryStream(hashes.SelectMany(mh => (byte[])mh).ToArray()))
27 | {
28 | foreach (var hash in hashes)
29 | {
30 | var mh = stream.ReadMultihash();
31 |
32 | Assert.NotNull(mh);
33 | Assert.Equal(mh, hash);
34 | Assert.True(mh.Verify(data));
35 | }
36 | }
37 | }
38 |
39 | [Fact]
40 | public async Task Read_StreamGivenMultistreamContent_ReturnsValidMultihashes_Async()
41 | {
42 | var data = Encoding.UTF8.GetBytes("hello world");
43 | var hashes = SupportedHashTypes.Select(type => Multihash.Sum(type, data)).ToArray();
44 |
45 | using (var stream = new MemoryStream(hashes.SelectMany(mh => (byte[])mh).ToArray()))
46 | {
47 | foreach (var hash in hashes)
48 | {
49 | var mh = await stream.ReadMultihashAsync(CancellationToken.None);
50 |
51 | Assert.NotNull(mh);
52 | Assert.Equal(mh, hash);
53 | Assert.True(mh.Verify(data));
54 | }
55 | }
56 | }
57 |
58 | [Fact]
59 | public void ReadWrite_Roundtrip()
60 | {
61 | var data = Encoding.UTF8.GetBytes("hello world");
62 | var hashes = SupportedHashTypes.Select(type => Multihash.Sum(type, data)).ToList();
63 |
64 | using (var stream = new MemoryStream())
65 | {
66 | foreach (var hash in hashes)
67 | {
68 | stream.Write(hash);
69 | }
70 |
71 | stream.Seek(0, SeekOrigin.Begin);
72 |
73 | foreach (var hash in hashes)
74 | {
75 | var mh = stream.ReadMultihash();
76 |
77 | Assert.NotNull(mh);
78 | Assert.Equal(mh, hash);
79 | Assert.True(mh.Verify(data));
80 | }
81 | }
82 | }
83 |
84 | [Fact]
85 | public async Task ReadWrite_Roundtrip_Async()
86 | {
87 | var data = Encoding.UTF8.GetBytes("hello world");
88 | var hashes = SupportedHashTypes.Select(type => Multihash.Sum(type, data)).ToList();
89 |
90 | using (var stream = new MemoryStream())
91 | {
92 | foreach (var hash in hashes)
93 | {
94 | await stream.WriteAsync(hash, CancellationToken.None);
95 | }
96 |
97 | stream.Seek(0, SeekOrigin.Begin);
98 |
99 | foreach (var hash in hashes)
100 | {
101 | var mh = await stream.ReadMultihashAsync(CancellationToken.None);
102 |
103 | Assert.NotNull(mh);
104 | Assert.Equal(mh, hash);
105 | Assert.True(mh.Verify(data));
106 | }
107 | }
108 | }
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/test/Multiformats.Hash.Tests/Multiformats.Hash.Tests.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | netcoreapp2.0;net461
5 | x64
6 | false
7 | $(NoWarn);NU1605
8 |
9 |
10 |
11 | true
12 | full
13 | false
14 | $(DefineConstants);DEBUG
15 |
16 |
17 |
18 | pdbonly
19 | true
20 | $(DefineConstants)
21 |
22 |
23 |
24 |
25 |
26 | false
27 | opencover
28 | [xunit.*]*
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 | all
38 | runtime; build; native; contentfiles; analyzers
39 |
40 |
41 |
42 |
43 | all
44 | runtime; build; native; contentfiles; analyzers
45 |
46 |
47 | all
48 | runtime; build; native; contentfiles; analyzers
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
--------------------------------------------------------------------------------
/test/Multiformats.Hash.Tests/MultihashTests.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Text;
5 | using System.Threading.Tasks;
6 | using BinaryEncoding;
7 | using Multiformats.Base;
8 | using Org.BouncyCastle.Utilities.Encoders;
9 | using Xunit;
10 |
11 | namespace Multiformats.Hash.Tests
12 | {
13 | public class MultihashTests
14 | {
15 | [Theory]
16 | [InlineData("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", 0x11, "sha1")]
17 | [InlineData("0beec7b5", 0x11, "sha1")]
18 | [InlineData("2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", 0x12, "sha2-256")]
19 | [InlineData("2c26b46b", 0x12, "sha2-256")]
20 | [InlineData("0beec7b5ea3f0fdbc9", 0xb220, "blake2b-256")]
21 | public void TestEncode(string hex, int code, string name)
22 | {
23 | var ob = Hex.Decode(hex);
24 | var nb = Binary.Varint.GetBytes((uint)code).Concat(Binary.Varint.GetBytes((uint)ob.Length)).Concat(ob).ToArray();
25 |
26 | var encoded = Multihash.Encode(ob, (HashType)code);
27 |
28 | Assert.Equal(encoded, nb);
29 |
30 | var h = TestCastToMultihash(hex, code, name);
31 | Assert.Equal((byte[])h, nb);
32 | }
33 |
34 | private static Multihash TestCastToMultihash(string hex, int code, string name)
35 | {
36 | var ob = Hex.Decode(hex);
37 | var b = Binary.Varint.GetBytes((uint) code).Concat(Binary.Varint.GetBytes((uint) ob.Length)).Concat(ob).ToArray();
38 | return Multihash.Cast(b);
39 | }
40 |
41 | [Fact]
42 | public void CanDecodeFromMultibase()
43 | {
44 | var hex = Multibase.Base58.Decode("8Vtkv2tdQ43bNGdWN9vNx9GVS9wrbXHk4ZW8kmucPmaYJwwedXir52kti9wJhcik4HehyqgLrQ1hBuirviLhxgRBNv");
45 | var mb = Multibase.Base32.Encode(hex);
46 |
47 | Assert.True(Multihash.TryParse(mb, out var mh));
48 | Assert.Equal(mh.ToBytes(), hex);
49 | }
50 |
51 | [Fact]
52 | public void CanDecodeFromMultibaseAndDetectEncoding()
53 | {
54 | var hex = Multibase.Base58.Decode("8Vtkv2tdQ43bNGdWN9vNx9GVS9wrbXHk4ZW8kmucPmaYJwwedXir52kti9wJhcik4HehyqgLrQ1hBuirviLhxgRBNv");
55 | var mb = Multibase.Base32.Encode(hex);
56 |
57 | Assert.True(Multihash.TryParse(mb, out var mh, out var encoding));
58 | Assert.Equal(mh.ToBytes(), hex);
59 | Assert.Equal(encoding, MultibaseEncoding.Base32Lower);
60 | }
61 |
62 | [Fact]
63 | public void CanDecodeFromMultibaseWithKnownEncoding()
64 | {
65 | var hex = Multibase.Base58.Decode("8Vtkv2tdQ43bNGdWN9vNx9GVS9wrbXHk4ZW8kmucPmaYJwwedXir52kti9wJhcik4HehyqgLrQ1hBuirviLhxgRBNv");
66 | var mb = Multibase.Base32.Encode(hex);
67 |
68 | Assert.True(Multihash.TryParse(mb, MultibaseEncoding.Base32Lower, out var mh));
69 | Assert.Equal(mh.ToBytes(), hex);
70 | }
71 |
72 | [Theory]
73 | [InlineData("2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", 0x00, "id")]
74 | [InlineData("", 0x00, "id")]
75 | [InlineData("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33", 0x11, "sha1")]
76 | [InlineData("0beec7b5", 0x11, "sha1")]
77 | [InlineData("2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae", 0x12, "sha2-256")]
78 | [InlineData("2c26b46b", 0x12, "sha2-256")]
79 | [InlineData("0beec7b5ea3f0fdbc9", 0xb220, "blake2b-256")]
80 | public void TestDecode(string hex, int code, string name)
81 | {
82 | var ob = Hex.Decode(hex);
83 | var nb = Binary.Varint.GetBytes((uint)code).Concat(Binary.Varint.GetBytes((uint)ob.Length)).Concat(ob).ToArray();
84 |
85 | var dec = Multihash.Decode(nb);
86 | Assert.Equal((int)dec.Code, code);
87 | Assert.Equal(dec.Name, name);
88 | Assert.Equal(dec.Length, ob.Length);
89 | Assert.Equal(dec.Digest, ob);
90 | }
91 |
92 | public static IEnumerable