-
-
Notifications
You must be signed in to change notification settings - Fork 419
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Implement RFC 47 (Serialise signature)
This change implements deterministic package and program signatures based on the contents and dependencies of the packages. Signatures are computed by hashing the serialised package ASTs with the BLAKE2 hash function. This hash function was chosen for its good speed and low collision rate. The signature computation handles circular dependencies by computing signatures per package cycle instead of per package. Packages in the same group are discriminated by a group index. In order to allow deterministic signatures, file parsing order is now always alphabetical inside of a package. The compiler now outputs the package groups and dependencies when the `-V3` or `-V4` flags are enabled. Signatures will be used for future work on separate package compilation in order to validate package identities. Closes #2147.
- Loading branch information
1 parent
9b51e1a
commit 087c1c4
Showing
26 changed files
with
2,180 additions
and
70 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
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,160 @@ | ||
| /* | ||
| BLAKE2 reference source code package - reference C implementations | ||
| Copyright 2012, Samuel Neves <[email protected]>. You may use this under the | ||
| terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at | ||
| your option. The terms of these licenses can be found at: | ||
| - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 | ||
| - OpenSSL license : https://www.openssl.org/source/license.html | ||
| - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 | ||
| More information about the BLAKE2 hash function can be found at | ||
| https://blake2.net. | ||
| */ | ||
| #ifndef BLAKE2_IMPL_H | ||
| #define BLAKE2_IMPL_H | ||
|
|
||
| #include <stdint.h> | ||
| #include <string.h> | ||
|
|
||
| #if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L) | ||
| #if defined(_MSC_VER) | ||
| #define BLAKE2_INLINE __inline | ||
| #elif defined(__GNUC__) | ||
| #define BLAKE2_INLINE __inline__ | ||
| #else | ||
| #define BLAKE2_INLINE | ||
| #endif | ||
| #else | ||
| #define BLAKE2_INLINE inline | ||
| #endif | ||
|
|
||
| static BLAKE2_INLINE uint32_t load32( const void *src ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| uint32_t w; | ||
| memcpy(&w, src, sizeof w); | ||
| return w; | ||
| #else | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint32_t )( p[0] ) << 0) | | ||
| (( uint32_t )( p[1] ) << 8) | | ||
| (( uint32_t )( p[2] ) << 16) | | ||
| (( uint32_t )( p[3] ) << 24) ; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint64_t load64( const void *src ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| uint64_t w; | ||
| memcpy(&w, src, sizeof w); | ||
| return w; | ||
| #else | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint64_t )( p[0] ) << 0) | | ||
| (( uint64_t )( p[1] ) << 8) | | ||
| (( uint64_t )( p[2] ) << 16) | | ||
| (( uint64_t )( p[3] ) << 24) | | ||
| (( uint64_t )( p[4] ) << 32) | | ||
| (( uint64_t )( p[5] ) << 40) | | ||
| (( uint64_t )( p[6] ) << 48) | | ||
| (( uint64_t )( p[7] ) << 56) ; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint16_t load16( const void *src ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| uint16_t w; | ||
| memcpy(&w, src, sizeof w); | ||
| return w; | ||
| #else | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint16_t )( p[0] ) << 0) | | ||
| (( uint16_t )( p[1] ) << 8) ; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store16( void *dst, uint16_t w ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| memcpy(dst, &w, sizeof w); | ||
| #else | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| *p++ = ( uint8_t )w; w >>= 8; | ||
| *p++ = ( uint8_t )w; | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store32( void *dst, uint32_t w ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| memcpy(dst, &w, sizeof w); | ||
| #else | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| p[0] = (uint8_t)(w >> 0); | ||
| p[1] = (uint8_t)(w >> 8); | ||
| p[2] = (uint8_t)(w >> 16); | ||
| p[3] = (uint8_t)(w >> 24); | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store64( void *dst, uint64_t w ) | ||
| { | ||
| #if defined(NATIVE_LITTLE_ENDIAN) | ||
| memcpy(dst, &w, sizeof w); | ||
| #else | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| p[0] = (uint8_t)(w >> 0); | ||
| p[1] = (uint8_t)(w >> 8); | ||
| p[2] = (uint8_t)(w >> 16); | ||
| p[3] = (uint8_t)(w >> 24); | ||
| p[4] = (uint8_t)(w >> 32); | ||
| p[5] = (uint8_t)(w >> 40); | ||
| p[6] = (uint8_t)(w >> 48); | ||
| p[7] = (uint8_t)(w >> 56); | ||
| #endif | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint64_t load48( const void *src ) | ||
| { | ||
| const uint8_t *p = ( const uint8_t * )src; | ||
| return (( uint64_t )( p[0] ) << 0) | | ||
| (( uint64_t )( p[1] ) << 8) | | ||
| (( uint64_t )( p[2] ) << 16) | | ||
| (( uint64_t )( p[3] ) << 24) | | ||
| (( uint64_t )( p[4] ) << 32) | | ||
| (( uint64_t )( p[5] ) << 40) ; | ||
| } | ||
|
|
||
| static BLAKE2_INLINE void store48( void *dst, uint64_t w ) | ||
| { | ||
| uint8_t *p = ( uint8_t * )dst; | ||
| p[0] = (uint8_t)(w >> 0); | ||
| p[1] = (uint8_t)(w >> 8); | ||
| p[2] = (uint8_t)(w >> 16); | ||
| p[3] = (uint8_t)(w >> 24); | ||
| p[4] = (uint8_t)(w >> 32); | ||
| p[5] = (uint8_t)(w >> 40); | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint32_t rotr32( const uint32_t w, const unsigned c ) | ||
| { | ||
| return ( w >> c ) | ( w << ( 32 - c ) ); | ||
| } | ||
|
|
||
| static BLAKE2_INLINE uint64_t rotr64( const uint64_t w, const unsigned c ) | ||
| { | ||
| return ( w >> c ) | ( w << ( 64 - c ) ); | ||
| } | ||
|
|
||
| /* prevents compiler optimizing out memset() */ | ||
| static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n) | ||
| { | ||
| static void *(*const volatile memset_v)(void *, int, size_t) = &memset; | ||
| memset_v(v, 0, n); | ||
| } | ||
|
|
||
| #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,91 @@ | ||
| /* | ||
| BLAKE2 reference source code package - reference C implementations | ||
| Copyright 2012, Samuel Neves <[email protected]>. You may use this under the | ||
| terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at | ||
| your option. The terms of these licenses can be found at: | ||
| - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0 | ||
| - OpenSSL license : https://www.openssl.org/source/license.html | ||
| - Apache 2.0 : http://www.apache.org/licenses/LICENSE-2.0 | ||
| More information about the BLAKE2 hash function can be found at | ||
| https://blake2.net. | ||
| */ | ||
| #ifndef BLAKE2_H | ||
| #define BLAKE2_H | ||
|
|
||
| #include <stddef.h> | ||
| #include <stdint.h> | ||
|
|
||
| #if defined(_MSC_VER) | ||
| #define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop)) | ||
| #else | ||
| #define BLAKE2_PACKED(x) x __attribute__((packed)) | ||
| #endif | ||
|
|
||
| #if defined(__cplusplus) | ||
| extern "C" { | ||
| #endif | ||
|
|
||
| enum blake2b_constant | ||
| { | ||
| BLAKE2B_BLOCKBYTES = 128, | ||
| BLAKE2B_OUTBYTES = 64, | ||
| BLAKE2B_KEYBYTES = 64, | ||
| BLAKE2B_SALTBYTES = 16, | ||
| BLAKE2B_PERSONALBYTES = 16 | ||
| }; | ||
|
|
||
| typedef struct blake2b_state__ | ||
| { | ||
| uint64_t h[8]; | ||
| uint64_t t[2]; | ||
| uint64_t f[2]; | ||
| uint8_t buf[BLAKE2B_BLOCKBYTES]; | ||
| size_t buflen; | ||
| size_t outlen; | ||
| uint8_t last_node; | ||
| } blake2b_state; | ||
|
|
||
| BLAKE2_PACKED(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 */ | ||
| uint32_t node_offset; /* 12 */ | ||
| uint32_t xof_length; /* 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 */ | ||
| }); | ||
|
|
||
| typedef struct blake2b_param__ blake2b_param; | ||
|
|
||
| /* Padded structs result in a compile-time error */ | ||
| enum { | ||
| BLAKE2_DUMMY_2 = 1/(int)(sizeof(blake2b_param) == BLAKE2B_OUTBYTES) | ||
| }; | ||
|
|
||
| /* Streaming API */ | ||
| int blake2b_init( blake2b_state *S, size_t outlen ); | ||
| int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen ); | ||
| int blake2b_init_param( blake2b_state *S, const blake2b_param *P ); | ||
| int blake2b_update( blake2b_state *S, const void *in, size_t inlen ); | ||
| int blake2b_final( blake2b_state *S, void *out, size_t outlen ); | ||
|
|
||
| /* Simple API */ | ||
| int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
|
|
||
| /* This is simply an alias for blake2b */ | ||
| int blake2( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen ); | ||
|
|
||
| #if defined(__cplusplus) | ||
| } | ||
| #endif | ||
|
|
||
| #endif |
Oops, something went wrong.