Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
0 parents
commit 1813775
Showing
10 changed files
with
871 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,19 @@ | ||
Copyright (c) 2012 strawbrary | ||
|
||
Permission is hereby granted, free of charge, to any person obtaining a copy | ||
of this software and associated documentation files (the "Software"), to deal | ||
in the Software without restriction, including without limitation the rights | ||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | ||
copies of the Software, and to permit persons to whom the Software is | ||
furnished to do so, subject to the following conditions: | ||
|
||
The above copyright notice and this permission notice shall be included in | ||
all copies or substantial portions of the Software. | ||
|
||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | ||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | ||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | ||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | ||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN | ||
THE SOFTWARE. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,55 @@ | ||
PHP BLAKE2 Extension | ||
============================ | ||
BLAKE2 is an improved version of BLAKE, one the finalists in the NIST SHA-3 competition. Like BLAKE or SHA-3, BLAKE2 offers the highest security, yet is fast as MD5 on 64-bit platforms and requires at least 33% less RAM than SHA-2 or SHA-3 on low-end systems. This implementation uses the BLAKE2b variant of the algorithm which is optimized for 64-bit systems. The algorithm was designed by Jean-Philippe Aumasson, Samuel Neves, Zooko Wilcox-O'Hearn, and Christian Winnerlein. | ||
|
||
Installation | ||
------------ | ||
1. git clone https://github.com/strawbrary/php-blake2 | ||
1. cd php-blake2 | ||
1. phpize | ||
1. ./configure --enable-blake2 | ||
1. make && make install | ||
1. Add the following line to your php.ini file | ||
|
||
``` | ||
extension=blake2.so | ||
``` | ||
|
||
You may need to restart your httpd to load the extension | ||
|
||
Usage | ||
---- | ||
```php | ||
string blake2 ( string $str [, int $outputSize = 64, string $key, bool $rawOutput = false ] ) | ||
``` | ||
|
||
* $str: The string to hash | ||
* $outputSize: The length of the output hash (can be between 1 and 64) | ||
* $key: Turns the output into a keyed hash using the specified key | ||
* $rawOutput: If set to true, then the hash is returned in raw binary format | ||
|
||
* Return value: A hex string containing the BLAKE2 hash of the input string | ||
|
||
Examples | ||
-------- | ||
```php | ||
echo blake2(''); | ||
``` | ||
|
||
786a02f742015903c6c6fd852552d272912f4740e15847618a86e217f71f5419d25e1031afee585313896444934eb04b903a685b1448b755d56f701afe9be2ce | ||
|
||
```php | ||
echo blake2('Hello world', 20); | ||
``` | ||
|
||
5ad31b81fc4dde5554e36af1e884d83ff5b24eb0 | ||
|
||
```php | ||
echo blake2('Hello world', 20, 'foobar'); | ||
``` | ||
|
||
5b4bbc84b59ab5d9146089b143fd52f38638dcac | ||
|
||
More Info | ||
--------- | ||
https://blake2.net/ |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,121 @@ | ||
#pragma once | ||
#ifndef __BLAKE2_IMPL_H__ | ||
#define __BLAKE2_IMPL_H__ | ||
|
||
#include <stdint.h> | ||
|
||
static inline uint32_t load32( const void *src ) | ||
{ | ||
#if defined(NATIVE_LITTLE_ENDIAN) | ||
return *( uint32_t * )( src ); | ||
#else | ||
const uint8_t *p = ( uint8_t * )src; | ||
uint32_t w = *p++; | ||
w |= ( uint32_t )( *p++ ) << 8; | ||
w |= ( uint32_t )( *p++ ) << 16; | ||
w |= ( uint32_t )( *p++ ) << 24; | ||
return w; | ||
#endif | ||
} | ||
|
||
static inline uint64_t load64( const void *src ) | ||
{ | ||
#if defined(NATIVE_LITTLE_ENDIAN) | ||
return *( uint64_t * )( src ); | ||
#else | ||
const uint8_t *p = ( uint8_t * )src; | ||
uint64_t w = *p++; | ||
w |= ( uint64_t )( *p++ ) << 8; | ||
w |= ( uint64_t )( *p++ ) << 16; | ||
w |= ( uint64_t )( *p++ ) << 24; | ||
w |= ( uint64_t )( *p++ ) << 32; | ||
w |= ( uint64_t )( *p++ ) << 40; | ||
w |= ( uint64_t )( *p++ ) << 48; | ||
w |= ( uint64_t )( *p++ ) << 56; | ||
return w; | ||
#endif | ||
} | ||
|
||
static inline void store32( void *dst, uint32_t w ) | ||
{ | ||
#if defined(NATIVE_LITTLE_ENDIAN) | ||
*( uint32_t * )( dst ) = w; | ||
#else | ||
uint8_t *p = ( uint8_t * )dst; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; | ||
#endif | ||
} | ||
|
||
static inline void store64( void *dst, uint64_t w ) | ||
{ | ||
#if defined(NATIVE_LITTLE_ENDIAN) | ||
*( uint64_t * )( dst ) = w; | ||
#else | ||
uint8_t *p = ( uint8_t * )dst; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; | ||
#endif | ||
} | ||
|
||
static inline uint64_t load48( const void *src ) | ||
{ | ||
const uint8_t *p = ( const uint8_t * )src; | ||
uint64_t w = *p++; | ||
w |= ( uint64_t )( *p++ ) << 8; | ||
w |= ( uint64_t )( *p++ ) << 16; | ||
w |= ( uint64_t )( *p++ ) << 24; | ||
w |= ( uint64_t )( *p++ ) << 32; | ||
w |= ( uint64_t )( *p++ ) << 40; | ||
return w; | ||
} | ||
|
||
static inline void store48( void *dst, uint64_t w ) | ||
{ | ||
uint8_t *p = ( uint8_t * )dst; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; w >>= 8; | ||
*p++ = ( uint8_t )w; | ||
} | ||
|
||
static inline uint32_t rotl32( const uint32_t w, const unsigned c ) | ||
{ | ||
return ( w << c ) | ( w >> ( 32 - c ) ); | ||
} | ||
|
||
static inline uint64_t rotl64( const uint64_t w, const unsigned c ) | ||
{ | ||
return ( w << c ) | ( w >> ( 64 - c ) ); | ||
} | ||
|
||
static inline uint32_t rotr32( const uint32_t w, const unsigned c ) | ||
{ | ||
return ( w >> c ) | ( w << ( 32 - c ) ); | ||
} | ||
|
||
static inline uint64_t rotr64( const uint64_t w, const unsigned c ) | ||
{ | ||
return ( w >> c ) | ( w << ( 64 - c ) ); | ||
} | ||
|
||
/* prevents compiler optimizing out memset() */ | ||
static inline void secure_zero_memory( void *v, size_t n ) | ||
{ | ||
volatile uint8_t *p = ( volatile uint8_t * )v; | ||
|
||
while( n-- ) *p++ = 0; | ||
} | ||
|
||
#endif | ||
|
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,144 @@ | ||
#pragma once | ||
#ifndef __BLAKE2_H__ | ||
#define __BLAKE2_H__ | ||
|
||
#include <stddef.h> | ||
#include <stdint.h> | ||
|
||
#if defined(_MSC_VER) | ||
#define ALIGN(x) __declspec(align(x)) | ||
#else | ||
#define ALIGN(x) __attribute__((aligned(x))) | ||
#endif | ||
|
||
#if defined(__cplusplus) | ||
extern "C" { | ||
#endif | ||
|
||
enum blake2s_constant | ||
{ | ||
BLAKE2S_BLOCKBYTES = 64, | ||
BLAKE2S_OUTBYTES = 32, | ||
BLAKE2S_KEYBYTES = 32, | ||
BLAKE2S_SALTBYTES = 8, | ||
BLAKE2S_PERSONALBYTES = 8 | ||
}; | ||
|
||
enum blake2b_constant | ||
{ | ||
BLAKE2B_BLOCKBYTES = 128, | ||
BLAKE2B_OUTBYTES = 64, | ||
BLAKE2B_KEYBYTES = 64, | ||
BLAKE2B_SALTBYTES = 16, | ||
BLAKE2B_PERSONALBYTES = 16 | ||
}; | ||
|
||
#pragma pack(push, 1) | ||
typedef struct __blake2s_param | ||
{ | ||
uint8_t digest_length; // 1 | ||
uint8_t key_length; // 2 | ||
uint8_t fanout; // 3 | ||
uint8_t depth; // 4 | ||
uint32_t leaf_length; // 8 | ||
uint8_t node_offset[6];// 14 | ||
uint8_t node_depth; // 15 | ||
uint8_t inner_length; // 16 | ||
// uint8_t reserved[0]; | ||
uint8_t salt[BLAKE2B_SALTBYTES]; // 24 | ||
uint8_t personal[BLAKE2S_PERSONALBYTES]; // 32 | ||
} blake2s_param; | ||
|
||
ALIGN( 64 ) typedef struct __blake2s_state | ||
{ | ||
uint32_t h[8]; | ||
uint32_t t[2]; | ||
uint32_t f[2]; | ||
uint8_t buf[2 * BLAKE2S_BLOCKBYTES]; | ||
size_t buflen; | ||
uint8_t last_node; | ||
} blake2s_state ; | ||
|
||
typedef struct __blake2b_param | ||
{ | ||
uint8_t digest_length; // 1 | ||
uint8_t key_length; // 2 | ||
uint8_t fanout; // 3 | ||
uint8_t depth; // 4 | ||
uint32_t leaf_length; // 8 | ||
uint64_t node_offset; // 16 | ||
uint8_t node_depth; // 17 | ||
uint8_t inner_length; // 18 | ||
uint8_t reserved[14]; // 32 | ||
uint8_t salt[BLAKE2B_SALTBYTES]; // 48 | ||
uint8_t personal[BLAKE2B_PERSONALBYTES]; // 64 | ||
} blake2b_param; | ||
|
||
ALIGN( 64 ) typedef struct __blake2b_state | ||
{ | ||
uint64_t h[8]; | ||
uint64_t t[2]; | ||
uint64_t f[2]; | ||
uint8_t buf[2 * BLAKE2B_BLOCKBYTES]; | ||
size_t buflen; | ||
uint8_t last_node; | ||
} blake2b_state; | ||
|
||
typedef struct __blake2sp_state | ||
{ | ||
blake2s_state S[8][1]; | ||
blake2s_state R[1]; | ||
uint8_t buf[8 * BLAKE2S_BLOCKBYTES]; | ||
size_t buflen; | ||
} blake2sp_state; | ||
|
||
typedef struct __blake2bp_state | ||
{ | ||
blake2b_state S[4][1]; | ||
blake2b_state R[1]; | ||
uint8_t buf[4 * BLAKE2B_BLOCKBYTES]; | ||
size_t buflen; | ||
} blake2bp_state; | ||
#pragma pack(pop) | ||
|
||
// Streaming API | ||
int blake2s_init( blake2s_state *S, const uint8_t outlen ); | ||
int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ); | ||
int blake2s_init_param( blake2s_state *S, const blake2s_param *P ); | ||
int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen ); | ||
int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen ); | ||
|
||
int blake2b_init( blake2b_state *S, const uint8_t outlen ); | ||
int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ); | ||
int blake2b_init_param( blake2b_state *S, const blake2b_param *P ); | ||
int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen ); | ||
int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen ); | ||
|
||
int blake2sp_init( blake2sp_state *S, const uint8_t outlen ); | ||
int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ); | ||
int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen ); | ||
int blake2sp_final( blake2sp_state *S, uint8_t *out, uint8_t outlen ); | ||
|
||
int blake2bp_init( blake2bp_state *S, const uint8_t outlen ); | ||
int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen ); | ||
int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen ); | ||
int blake2bp_final( blake2bp_state *S, uint8_t *out, uint8_t outlen ); | ||
|
||
// Simple API | ||
int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); | ||
int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); | ||
|
||
int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); | ||
int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ); | ||
|
||
static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen ) | ||
{ | ||
return blake2b( out, in, key, outlen, inlen, keylen ); | ||
} | ||
|
||
#if defined(__cplusplus) | ||
} | ||
#endif | ||
|
||
#endif | ||
|
Oops, something went wrong.