├── .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://img.shields.io/badge/project-multiformats-blue.svg?style=flat-square)](https://github.com/multiformats/multiformats) 6 | [![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](https://webchat.freenode.net/?channels=%23ipfs) 7 | [![Travis CI](https://img.shields.io/travis/multiformats/cs-multihash.svg?style=flat-square&branch=master)](https://travis-ci.org/multiformats/cs-multihash) 8 | [![AppVeyor](https://img.shields.io/appveyor/ci/tabrath/cs-multihash/master.svg?style=flat-square)](https://ci.appveyor.com/project/tabrath/cs-multihash) 9 | [![NuGet](https://buildstats.info/nuget/Multiformats.Hash)](https://www.nuget.org/packages/Multiformats.Hash/) 10 | [![](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme) 11 | [![Codecov](https://img.shields.io/codecov/c/github/multiformats/cs-multihash/master.svg?style=flat-square)](https://codecov.io/gh/multiformats/cs-multihash) 12 | [![Libraries.io](https://img.shields.io/librariesio/github/multiformats/cs-multihash.svg?style=flat-square)](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 GetSupportedHashTable() => Multihash.SupportedHashCodes.Select(h => new object[] { (int)h, Multihash.GetName(h) }); 93 | 94 | [Theory] 95 | [MemberData(nameof(GetSupportedHashTable), DisableDiscoveryEnumeration = false)] 96 | public void TestTable(int code, string name) 97 | { 98 | if (Multihash.GetName(code) != name) 99 | Assert.True(false, $"Table mismatch: {Multihash.GetName(code)}, {name}"); 100 | 101 | if ((int)Multihash.GetCode(name) != code) 102 | Assert.True(false, $"Table mismatch: {Multihash.GetCode(name)}, {code}"); 103 | } 104 | 105 | [Theory] 106 | [InlineData("5drNu81uhrFLRiS4bxWgAkpydaLUPW", "hello world")] // sha1 107 | [InlineData("QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4", "hello world")] // sha2_256 108 | [InlineData("8Vtkv2tdQ43bNGdWN9vNx9GVS9wrbXHk4ZW8kmucPmaYJwwedXir52kti9wJhcik4HehyqgLrQ1hBuirviLhxgRBNv", "hello world")] // sha2_512 109 | [InlineData("8tWhXW5oUwtPd9d3FnjuLP1NozN3vc45rmsoWEEfrZL1L6gi9dqi1YkZu5iHb2HJ8WbZaaKAyNWWRAa8yaxMkGKJmX", "hello world")] // sha3_512 110 | public void TestVerify(string mhs, string data) 111 | { 112 | var mh = Multihash.Parse(mhs); 113 | var bytes = Encoding.UTF8.GetBytes(data); 114 | 115 | Assert.True(mh.Verify(bytes)); 116 | } 117 | 118 | public static IEnumerable GetSupportedHashes() => Multihash.SupportedHashCodes.Select(h => new object[] { h }); 119 | 120 | [Theory] 121 | [MemberData(nameof(GetSupportedHashes), DisableDiscoveryEnumeration = false)] 122 | public void VerifyRoundTrip(HashType type) 123 | { 124 | var rand = new Random(Environment.TickCount); 125 | var bytes = new byte[rand.Next(1024, 4096)]; 126 | rand.NextBytes(bytes); 127 | 128 | var mh = Multihash.Sum(type, bytes, type == HashType.ID ? bytes.Length : -1); 129 | var str = mh.ToString(); 130 | var mh2 = Multihash.Parse(str); 131 | 132 | Assert.True(mh2.Verify(bytes)); 133 | } 134 | 135 | [Theory] 136 | [MemberData(nameof(GetSupportedHashes), DisableDiscoveryEnumeration = false)] 137 | public async Task VerifyRoundTripAsync(HashType type) 138 | { 139 | var rand = new Random(Environment.TickCount); 140 | var bytes = new byte[rand.Next(1024, 4096)]; 141 | rand.NextBytes(bytes); 142 | 143 | var mh = await Multihash.SumAsync(type, bytes, type == HashType.ID ? bytes.Length : -1); 144 | var str = mh.ToString(); 145 | var mh2 = Multihash.Parse(str); 146 | 147 | Assert.True(await mh2.VerifyAsync(bytes)); 148 | } 149 | 150 | [Theory] 151 | [MemberData(nameof(GetSupportedHashes), DisableDiscoveryEnumeration = false)] 152 | public void TestMultithreadedEnvironment(HashType type) 153 | { 154 | var rand = new Random(Environment.TickCount); 155 | var bytes = new byte[32*1024]; 156 | rand.NextBytes(bytes); 157 | 158 | Parallel.For(0, 200, _ => Multihash.Sum(type, bytes)); 159 | } 160 | } 161 | } 162 | -------------------------------------------------------------------------------- /test/Multiformats.Hash.Tests/SumTests.cs: -------------------------------------------------------------------------------- 1 | using System; 2 | using System.Linq; 3 | using System.Text; 4 | using Multiformats.Base; 5 | using Multiformats.Hash.Algorithms; 6 | using Org.BouncyCastle.Utilities.Encoders; 7 | using Xunit; 8 | 9 | namespace Multiformats.Hash.Tests 10 | { 11 | public class SumTests 12 | { 13 | [Fact] 14 | public void TestID() 15 | { 16 | var text = "hello world"; 17 | var hash = "1DVBjHhYDaZ47EzaX"; 18 | 19 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 20 | Assert.Equal(mh.ToString(MultibaseEncoding.Base58Btc), hash); 21 | } 22 | 23 | [Fact] 24 | public void TestSmallerLengthHashID() 25 | { 26 | var data = Encoding.UTF8.GetBytes("Identity hash input data."); 27 | var dataLength = data.Length; 28 | 29 | Multihash.Sum(data, dataLength); 30 | Multihash.Sum(data, -1); 31 | 32 | for (var l = dataLength - 1; l >= 0; l--) 33 | { 34 | Assert.Throws(() => Multihash.Sum(data, l)); 35 | } 36 | } 37 | 38 | [Fact] 39 | public void TestMD4() 40 | { 41 | var text = "hello world"; 42 | var hash = Hex.Decode("aa010fbc1d14c795d86ef98c95479d17"); 43 | 44 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 45 | Assert.Equal(hash, mh.Digest); 46 | } 47 | 48 | [Fact] 49 | public void TestMD5() 50 | { 51 | var text = "hello world"; 52 | var hash = Hex.Decode("5eb63bbbe01eeed093cb22bb8f5acdc3"); 53 | 54 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 55 | Assert.Equal(hash, mh.Digest); 56 | } 57 | 58 | [Fact] 59 | public void TestSHA1() 60 | { 61 | var text = "hello world"; 62 | var hash = "5drNu81uhrFLRiS4bxWgAkpydaLUPW"; 63 | 64 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 65 | Assert.Equal(mh.ToString(MultibaseEncoding.Base58Btc), hash); 66 | } 67 | 68 | [Fact] 69 | public void TestSHA2_256() 70 | { 71 | var text = "hello world"; 72 | var hash = "QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4"; 73 | 74 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 75 | Assert.Equal(mh.ToString(MultibaseEncoding.Base58Btc), hash); 76 | } 77 | 78 | [Fact] 79 | public void TestSHA2_512() 80 | { 81 | var text = "hello world"; 82 | var hash = "8Vtkv2tdQ43bNGdWN9vNx9GVS9wrbXHk4ZW8kmucPmaYJwwedXir52kti9wJhcik4HehyqgLrQ1hBuirviLhxgRBNv"; 83 | 84 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 85 | Assert.Equal(mh.ToString(MultibaseEncoding.Base58Btc), hash); 86 | } 87 | 88 | [Fact] 89 | public void TestSHA3_512() 90 | { 91 | var text = "hello world"; 92 | var hash = "8tWhXW5oUwtPd9d3FnjuLP1NozN3vc45rmsoWEEfrZL1L6gi9dqi1YkZu5iHb2HJ8WbZaaKAyNWWRAa8yaxMkGKJmX"; 93 | 94 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 95 | Assert.Equal(mh.ToString(MultibaseEncoding.Base58Btc), hash); 96 | } 97 | 98 | [Fact] 99 | public void TestSHA3_384() 100 | { 101 | var text = "hello world"; 102 | var hash = Hex.Decode("83bff28dde1b1bf5810071c6643c08e5b05bdb836effd70b403ea8ea0a634dc4997eb1053aa3593f590f9c63630dd90b"); 103 | 104 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 105 | Assert.Equal(mh.Digest, hash); 106 | } 107 | 108 | [Fact] 109 | public void TestSHA3_256() 110 | { 111 | var text = "hello world"; 112 | var hash = Hex.Decode("644bcc7e564373040999aac89e7622f3ca71fba1d972fd94a31c3bfbf24e3938"); 113 | 114 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 115 | Assert.Equal(mh.Digest, hash); 116 | } 117 | 118 | [Fact] 119 | public void TestSHA3_224() 120 | { 121 | var text = "hello world"; 122 | var hash = Hex.Decode("dfb7f18c77e928bb56faeb2da27291bd790bc1045cde45f3210bb6c5"); 123 | 124 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 125 | Assert.Equal(mh.Digest, hash); 126 | } 127 | 128 | [Fact] 129 | public void TestBlake2B() 130 | { 131 | var text = "hello world"; 132 | var hash = "021ced8799296ceca557832ab941a50b4a11f83478cf141f51f933f653ab9fbcc05a037cddbed06e309bf334942c4e58cdf1a46e237911ccd7fcf9787cbc7fd0"; 133 | 134 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 135 | Assert.Equal(BitConverter.ToString(mh.Digest).Replace("-", "").ToLower(), hash); 136 | } 137 | 138 | [Fact] 139 | public void TestBlake2BAll() 140 | { 141 | var text = "hello world"; 142 | 143 | foreach (var type in Enum.GetNames(typeof(HashType)).Where(t => t.StartsWith("BLAKE2B")).Select(n => (HashType)Enum.Parse(typeof(HashType), n))) 144 | { 145 | var mh = Multihash.Sum(type, Encoding.UTF8.GetBytes(text)); 146 | Assert.Equal(type, mh.Code); 147 | } 148 | } 149 | 150 | [Fact] 151 | public void TestBlake2S() 152 | { 153 | var text = "hello world"; 154 | var hash = "9aec6806794561107e594b1f6a8a6b0c92a0cba9acf5e5e93cca06f781813b0b"; 155 | 156 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 157 | Assert.Equal(BitConverter.ToString(mh.Digest).Replace("-", "").ToLower(), hash); 158 | } 159 | 160 | [Fact] 161 | public void TestBlake2SAll() 162 | { 163 | var text = "hello world"; 164 | 165 | foreach (var type in Enum.GetNames(typeof(HashType)).Where(t => t.StartsWith("BLAKE2S")).Select(n => (HashType)Enum.Parse(typeof(HashType), n))) 166 | { 167 | var mh = Multihash.Sum(type, Encoding.UTF8.GetBytes(text)); 168 | Assert.Equal(type, mh.Code); 169 | } 170 | } 171 | 172 | [Fact] 173 | public void TestKeccak_224() 174 | { 175 | var text = "hello world"; 176 | var hash = Hex.Decode("25f3ecfebabe99686282f57f5c9e1f18244cfee2813d33f955aae568"); 177 | 178 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 179 | Assert.Equal(mh.Digest, hash); 180 | } 181 | 182 | [Fact] 183 | public void TestKeccak_256() 184 | { 185 | var text = "hello world"; 186 | var hash = Hex.Decode("47173285a8d7341e5e972fc677286384f802f8ef42a5ec5f03bbfa254cb01fad"); 187 | 188 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 189 | Assert.Equal(mh.Digest, hash); 190 | } 191 | 192 | [Fact] 193 | public void TestKeccak_384() 194 | { 195 | var text = "hello world"; 196 | var hash = Hex.Decode("65fc99339a2a40e99d3c40d695b22f278853ca0f925cde4254bcae5e22ece47e6441f91b6568425adc9d95b0072eb49f"); 197 | 198 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 199 | Assert.Equal(mh.Digest, hash); 200 | } 201 | 202 | [Fact] 203 | public void TestKeccak_512() 204 | { 205 | var text = "hello world"; 206 | var hash = Hex.Decode("3ee2b40047b8060f68c67242175660f4174d0af5c01d47168ec20ed619b0b7c42181f40aa1046f39e2ef9efc6910782a998e0013d172458957957fac9405b67d"); 207 | 208 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 209 | Assert.Equal(mh.Digest, hash); 210 | } 211 | 212 | [Fact] 213 | public void TestShake_128() 214 | { 215 | var text = "hello world"; 216 | var hash = Hex.Decode("3a9159f071e4dd1c8c4f968607c30942"); 217 | 218 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 219 | Assert.Equal(mh.Digest, hash); 220 | } 221 | 222 | [Fact] 223 | public void TestShake_256() 224 | { 225 | var text = "hello world"; 226 | var hash = Hex.Decode("369771bb2cb9d2b04c1d54cca487e372d9f187f73f7ba3f65b95c8ee7798c527"); 227 | 228 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 229 | Assert.Equal(mh.Digest, hash); 230 | } 231 | 232 | [Fact] 233 | public void TestDblSha2_256() 234 | { 235 | var text = "foo"; 236 | var hash = Hex.Decode("c7ade88fc7a21498a6a5e5c385e1f68bed822b72aa63c4a9a48a02c2466ee29e"); 237 | 238 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 239 | Assert.Equal(mh.Digest, hash); 240 | } 241 | 242 | [Fact] 243 | public void TestMurmur3_128() 244 | { 245 | var text = "beep boop"; 246 | var hash = Hex.Decode("acfe9c5bbf88f075c0c4df0464430ead"); 247 | 248 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 249 | Assert.Equal(mh.Digest, hash); 250 | } 251 | 252 | [Fact] 253 | public void TestMurmur3_32() 254 | { 255 | var text = "beep boop"; 256 | var hash = Hex.Decode("243ddb9e"); 257 | 258 | var mh = Multihash.Sum(Encoding.UTF8.GetBytes(text)); 259 | Assert.Equal(mh.Digest, hash); 260 | } 261 | } 262 | } 263 | --------------------------------------------------------------------------------