liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Naming and coding style convention, new linter tool. (#945)

Browse Source 
* Makefile, Scripts: new linter
* About: remove ID from IC
* Firmware: remove double define for DIVC/DIVR
* Scripts: check folder names too. Docker: replace syntax check with make lint.
* Reformat Sources and Migrate to new file naming convention
* Docker: symlink clang-format-12 to clang-format
* Add coding style guide
This commit is contained in:
あく
2022-01-05 19:10:18 +03:00
committed by GitHub
parent c98e54da10
commit 389ff92cc1
899 changed files with 379245 additions and 373421 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
lib/toolbox/args.c
View File

@@ -21,7 +21,7 @@ bool args_read_int_and_trim(string_t args, int* value) {
return false;
}
if (sscanf(string_get_cstr(args), "%d", value) == 1) {
if(sscanf(string_get_cstr(args), "%d", value) == 1) {
string_right(args, cmd_length);
string_strim(args);
return true;

111
lib/toolbox/hmac_sha256.c
View File

@@ -30,94 +30,69 @@
#include "sha256.h"
#include "hmac_sha256.h"
static void
_hmac_sha256_init (const hmac_context *ctx)
{
hmac_sha256_context *context = (hmac_sha256_context *)ctx;
sha256_start(&context->sha_ctx);
static void _hmac_sha256_init(const hmac_context* ctx) {
hmac_sha256_context* context = (hmac_sha256_context*)ctx;
sha256_start(&context->sha_ctx);
}
static void
_hmac_sha256_update (const hmac_context *ctx, const uint8_t *message,
unsigned message_size)
{
hmac_sha256_context *context = (hmac_sha256_context *)ctx;
sha256_update(&context->sha_ctx, message, message_size);
_hmac_sha256_update(const hmac_context* ctx, const uint8_t* message, unsigned message_size) {
hmac_sha256_context* context = (hmac_sha256_context*)ctx;
sha256_update(&context->sha_ctx, message, message_size);
}
static void
_hmac_sha256_finish (const hmac_context *ctx, uint8_t *hash_result)
{
hmac_sha256_context *context = (hmac_sha256_context *)ctx;
sha256_finish(&context->sha_ctx, hash_result);
static void _hmac_sha256_finish(const hmac_context* ctx, uint8_t* hash_result) {
hmac_sha256_context* context = (hmac_sha256_context*)ctx;
sha256_finish(&context->sha_ctx, hash_result);
}
/* Compute an HMAC using K as a key (as in RFC 6979). Note that K is always
the same size as the hash result size. */
static void
hmac_init(const hmac_context *ctx, const uint8_t *K)
{
uint8_t *pad = ctx->tmp + 2 * ctx->result_size;
unsigned i;
for (i = 0; i < ctx->result_size; ++i)
pad[i] = K[i] ^ 0x36;
for (; i < ctx->block_size; ++i)
pad[i] = 0x36;
static void hmac_init(const hmac_context* ctx, const uint8_t* K) {
uint8_t* pad = ctx->tmp + 2 * ctx->result_size;
unsigned i;
for(i = 0; i < ctx->result_size; ++i) pad[i] = K[i] ^ 0x36;
for(; i < ctx->block_size; ++i) pad[i] = 0x36;
ctx->init_hash (ctx);
ctx->update_hash (ctx, pad, ctx->block_size);
ctx->init_hash(ctx);
ctx->update_hash(ctx, pad, ctx->block_size);
}
static void
hmac_update(const hmac_context *ctx,
const uint8_t *message,
unsigned message_size)
{
ctx->update_hash (ctx, message, message_size);
static void hmac_update(const hmac_context* ctx, const uint8_t* message, unsigned message_size) {
ctx->update_hash(ctx, message, message_size);
}
static void
hmac_finish(const hmac_context *ctx,
const uint8_t *K,
uint8_t *result)
{
uint8_t *pad = ctx->tmp + 2 * ctx->result_size;
unsigned i;
for (i = 0; i < ctx->result_size; ++i)
pad[i] = K[i] ^ 0x5c;
for (; i < ctx->block_size; ++i)
pad[i] = 0x5c;
static void hmac_finish(const hmac_context* ctx, const uint8_t* K, uint8_t* result) {
uint8_t* pad = ctx->tmp + 2 * ctx->result_size;
unsigned i;
for(i = 0; i < ctx->result_size; ++i) pad[i] = K[i] ^ 0x5c;
for(; i < ctx->block_size; ++i) pad[i] = 0x5c;
ctx->finish_hash (ctx, result);
ctx->finish_hash(ctx, result);
ctx->init_hash (ctx);
ctx->update_hash (ctx, pad, ctx->block_size);
ctx->update_hash (ctx, result, ctx->result_size);
ctx->finish_hash (ctx, result);
ctx->init_hash(ctx);
ctx->update_hash(ctx, pad, ctx->block_size);
ctx->update_hash(ctx, result, ctx->result_size);
ctx->finish_hash(ctx, result);
}
void
hmac_sha256_init (hmac_sha256_context *ctx, const uint8_t *K)
{
ctx->hmac_ctx.init_hash = _hmac_sha256_init;
ctx->hmac_ctx.update_hash = _hmac_sha256_update;
ctx->hmac_ctx.finish_hash = _hmac_sha256_finish;
ctx->hmac_ctx.block_size = 64;
ctx->hmac_ctx.result_size = 32;
ctx->hmac_ctx.tmp = ctx->tmp;
hmac_init (&ctx->hmac_ctx, K);
void hmac_sha256_init(hmac_sha256_context* ctx, const uint8_t* K) {
ctx->hmac_ctx.init_hash = _hmac_sha256_init;
ctx->hmac_ctx.update_hash = _hmac_sha256_update;
ctx->hmac_ctx.finish_hash = _hmac_sha256_finish;
ctx->hmac_ctx.block_size = 64;
ctx->hmac_ctx.result_size = 32;
ctx->hmac_ctx.tmp = ctx->tmp;
hmac_init(&ctx->hmac_ctx, K);
}
void
hmac_sha256_update (const hmac_sha256_context *ctx, const uint8_t *message,
unsigned message_size)
{
hmac_update (&ctx->hmac_ctx, message, message_size);
void hmac_sha256_update(
const hmac_sha256_context* ctx,
const uint8_t* message,
unsigned message_size) {
hmac_update(&ctx->hmac_ctx, message, message_size);
}
void
hmac_sha256_finish (const hmac_sha256_context *ctx, const uint8_t *K,
uint8_t *hash_result)
{
hmac_finish (&ctx->hmac_ctx, K, hash_result);
void hmac_sha256_finish(const hmac_sha256_context* ctx, const uint8_t* K, uint8_t* hash_result) {
hmac_finish(&ctx->hmac_ctx, K, hash_result);
}

38
lib/toolbox/hmac_sha256.h
View File

@@ -1,29 +1,27 @@
typedef struct hmac_context {
void (*init_hash)(const struct hmac_context *context);
void (*update_hash)(const struct hmac_context *context,
const uint8_t *message,
unsigned message_size);
void (*finish_hash)(const struct hmac_context *context, uint8_t *hash_result);
unsigned block_size; /* Hash function block size in bytes, eg 64 for SHA-256. */
unsigned result_size; /* Hash function result size in bytes, eg 32 for SHA-256. */
uint8_t *tmp; /* Must point to a buffer of at least (2 * result_size + block_size) bytes. */
void (*init_hash)(const struct hmac_context* context);
void (*update_hash)(
const struct hmac_context* context,
const uint8_t* message,
unsigned message_size);
void (*finish_hash)(const struct hmac_context* context, uint8_t* hash_result);
unsigned block_size; /* Hash function block size in bytes, eg 64 for SHA-256. */
unsigned result_size; /* Hash function result size in bytes, eg 32 for SHA-256. */
uint8_t* tmp; /* Must point to a buffer of at least (2 * result_size + block_size) bytes. */
} hmac_context;
typedef struct hmac_sha256_context {
hmac_context hmac_ctx;
sha256_context sha_ctx;
uint8_t tmp[32 * 2 + 64];
hmac_context hmac_ctx;
sha256_context sha_ctx;
uint8_t tmp[32 * 2 + 64];
} hmac_sha256_context;
void
hmac_sha256_init (hmac_sha256_context *ctx, const uint8_t *K);
void hmac_sha256_init(hmac_sha256_context* ctx, const uint8_t* K);
void
hmac_sha256_update (const hmac_sha256_context *ctx, const uint8_t *message,
unsigned message_size);
void hmac_sha256_update(
const hmac_sha256_context* ctx,
const uint8_t* message,
unsigned message_size);
void
hmac_sha256_finish (const hmac_sha256_context *ctx, const uint8_t *K,
uint8_t *hash_result);
void hmac_sha256_finish(const hmac_sha256_context* ctx, const uint8_t* K, uint8_t* hash_result);

6
lib/toolbox/manchester-decoder.c → lib/toolbox/manchester_decoder.c
View File

@@ -1,4 +1,4 @@
#include "manchester-decoder.h"
#include "manchester_decoder.h"
#include <stdint.h>
static const uint8_t transitions[] = {0b00000001, 0b10010001, 0b10011011, 0b11111011};
@@ -20,10 +20,10 @@ bool manchester_advance(
new_state = manchester_reset_state;
} else {
if(new_state == ManchesterStateMid0) {
if (data) *data = false;
if(data) *data = false;
result = true;
} else if(new_state == ManchesterStateMid1) {
if (data) *data = true;
if(data) *data = true;
result = true;
}
}

2
lib/toolbox/manchester-decoder.h → lib/toolbox/manchester_decoder.h
View File

@@ -20,8 +20,6 @@ typedef enum {
ManchesterStateStart0 = 3
} ManchesterState;
bool manchester_advance(
ManchesterState state,
ManchesterEvent event,

2
lib/toolbox/manchester-encoder.c → lib/toolbox/manchester_encoder.c
View File

@@ -1,4 +1,4 @@
#include "manchester-encoder.h"
#include "manchester_encoder.h"
#include <stdio.h>
void manchester_encoder_reset(ManchesterEncoderState* state) {

0
lib/toolbox/manchester-encoder.h → lib/toolbox/manchester_encoder.h
View File

3
lib/toolbox/random_name.c
View File

@@ -36,8 +36,7 @@ void set_random_name(char* name, uint8_t max_name_size) {
uint8_t prefix_i = rand() % SIZEOF_ARRAY(prefix);
uint8_t suffix_i = rand() % SIZEOF_ARRAY(suffix);
sniprintf(
name, max_name_size, "%s_%s", prefix[prefix_i], suffix[suffix_i]);
sniprintf(name, max_name_size, "%s_%s", prefix[prefix_i], suffix[suffix_i]);
// Set first symbol to upper case
name[0] = name[0] - 0x20;
}

40
lib/toolbox/saved_struct.c
View File

@@ -13,11 +13,7 @@ typedef struct {
uint32_t timestamp;
} SavedStructHeader;
bool saved_struct_save(const char* path,
void* data,
size_t size,
uint8_t magic,
uint8_t version) {
bool saved_struct_save(const char* path, void* data, size_t size, uint8_t magic, uint8_t version) {
furi_assert(path);
furi_assert(data);
furi_assert(size);
@@ -32,10 +28,7 @@ bool saved_struct_save(const char* path,
bool saved = storage_file_open(file, path, FSAM_WRITE, FSOM_CREATE_ALWAYS);
if(!saved) {
FURI_LOG_E(
TAG,
"Open failed \"%s\". Error: \'%s\'",
path,
storage_file_get_error_desc(file));
TAG, "Open failed \"%s\". Error: \'%s\'", path, storage_file_get_error_desc(file));
result = false;
}
@@ -58,10 +51,7 @@ bool saved_struct_save(const char* path,
if(bytes_count != (size + sizeof(header))) {
FURI_LOG_E(
TAG,
"Write failed \"%s\". Error: \'%s\'",
path,
storage_file_get_error_desc(file));
TAG, "Write failed \"%s\". Error: \'%s\'", path, storage_file_get_error_desc(file));
result = false;
}
}
@@ -72,11 +62,7 @@ bool saved_struct_save(const char* path,
return result;
}
bool saved_struct_load(const char* path,
void* data,
size_t size,
uint8_t magic,
uint8_t version) {
bool saved_struct_load(const char* path, void* data, size_t size, uint8_t magic, uint8_t version) {
FURI_LOG_I(TAG, "Loading \"%s\"", path);
SavedStructHeader header;
@@ -86,16 +72,13 @@ bool saved_struct_load(const char* path,
File* file = storage_file_alloc(storage);
bool result = true;
bool loaded = storage_file_open(file, path, FSAM_READ, FSOM_OPEN_EXISTING);
if (!loaded) {
if(!loaded) {
FURI_LOG_E(
TAG,
"Failed to read \"%s\". Error: %s",
path,
storage_file_get_error_desc(file));
TAG, "Failed to read \"%s\". Error: %s", path, storage_file_get_error_desc(file));
result = false;
}
if (result) {
if(result) {
uint16_t bytes_count = storage_file_read(file, &header, sizeof(SavedStructHeader));
bytes_count += storage_file_read(file, data_read, size);
@@ -126,16 +109,12 @@ bool saved_struct_load(const char* path,
if(header.checksum != checksum) {
FURI_LOG_E(
TAG,
"Checksum(%d != %d) mismatch of file \"%s\"",
header.checksum,
checksum,
path);
TAG, "Checksum(%d != %d) mismatch of file \"%s\"", header.checksum, checksum, path);
result = false;
}
}
if (result) {
if(result) {
memcpy(data, data_read, size);
}
@@ -146,4 +125,3 @@ bool saved_struct_load(const char* path,
return result;
}

13
lib/toolbox/saved_struct.h
View File

@@ -4,15 +4,6 @@
#include <stdbool.h>
#include <stddef.h>
bool saved_struct_load(const char* path,
void* data,
size_t size,
uint8_t magic,
uint8_t version);
bool saved_struct_save(const char* path,
void* data,
size_t size,
uint8_t magic,
uint8_t version);
bool saved_struct_load(const char* path, void* data, size_t size, uint8_t magic, uint8_t version);
bool saved_struct_save(const char* path, void* data, size_t size, uint8_t magic, uint8_t version);

259
lib/toolbox/sha256.c
View File

@@ -52,175 +52,170 @@
#define SHA256_MASK (SHA256_BLOCK_SIZE - 1)
static void memcpy_output_bswap32 (unsigned char *dst, const uint32_t *p)
{
int i;
uint32_t q = 0;
static void memcpy_output_bswap32(unsigned char* dst, const uint32_t* p) {
int i;
uint32_t q = 0;
for (i = 0; i < 32; i++)
{
if ((i & 3) == 0)
q = __builtin_bswap32 (p[i >> 2]); /* bswap32 is GCC extention */
dst[i] = q >> ((i & 3) * 8);
for(i = 0; i < 32; i++) {
if((i & 3) == 0) q = __builtin_bswap32(p[i >> 2]); /* bswap32 is GCC extention */
dst[i] = q >> ((i & 3) * 8);
}
}
#define rotr32(x,n) (((x) >> n) | ((x) << (32 - n)))
#define rotr32(x, n) (((x) >> n) | ((x) << (32 - n)))
#define ch(x,y,z) ((z) ^ ((x) & ((y) ^ (z))))
#define maj(x,y,z) (((x) & (y)) | ((z) & ((x) ^ (y))))
#define ch(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
#define maj(x, y, z) (((x) & (y)) | ((z) & ((x) ^ (y))))
/* round transforms for SHA256 compression functions */
#define vf(n,i) v[(n - i) & 7]
#define vf(n, i) v[(n - i) & 7]
#define hf(i) (p[i & 15] += \
g_1(p[(i + 14) & 15]) + p[(i + 9) & 15] + g_0(p[(i + 1) & 15]))
#define hf(i) (p[i & 15] += g_1(p[(i + 14) & 15]) + p[(i + 9) & 15] + g_0(p[(i + 1) & 15]))
#define v_cycle0(i) \
p[i] = __builtin_bswap32 (p[i]); \
vf(7,i) += p[i] + k_0[i] \
+ s_1(vf(4,i)) + ch(vf(4,i),vf(5,i),vf(6,i)); \
vf(3,i) += vf(7,i); \
vf(7,i) += s_0(vf(0,i))+ maj(vf(0,i),vf(1,i),vf(2,i))
#define v_cycle0(i) \
p[i] = __builtin_bswap32(p[i]); \
vf(7, i) += p[i] + k_0[i] + s_1(vf(4, i)) + ch(vf(4, i), vf(5, i), vf(6, i)); \
vf(3, i) += vf(7, i); \
vf(7, i) += s_0(vf(0, i)) + maj(vf(0, i), vf(1, i), vf(2, i))
#define v_cycle(i, j) \
vf(7,i) += hf(i) + k_0[i+j] \
+ s_1(vf(4,i)) + ch(vf(4,i),vf(5,i),vf(6,i)); \
vf(3,i) += vf(7,i); \
vf(7,i) += s_0(vf(0,i))+ maj(vf(0,i),vf(1,i),vf(2,i))
#define v_cycle(i, j) \
vf(7, i) += hf(i) + k_0[i + j] + s_1(vf(4, i)) + ch(vf(4, i), vf(5, i), vf(6, i)); \
vf(3, i) += vf(7, i); \
vf(7, i) += s_0(vf(0, i)) + maj(vf(0, i), vf(1, i), vf(2, i))
#define s_0(x) (rotr32((x), 2) ^ rotr32((x), 13) ^ rotr32((x), 22))
#define s_1(x) (rotr32((x), 6) ^ rotr32((x), 11) ^ rotr32((x), 25))
#define g_0(x) (rotr32((x), 7) ^ rotr32((x), 18) ^ ((x) >> 3))
#define g_1(x) (rotr32((x), 17) ^ rotr32((x), 19) ^ ((x) >> 10))
#define k_0 k256
#define s_0(x) (rotr32((x), 2) ^ rotr32((x), 13) ^ rotr32((x), 22))
#define s_1(x) (rotr32((x), 6) ^ rotr32((x), 11) ^ rotr32((x), 25))
#define g_0(x) (rotr32((x), 7) ^ rotr32((x), 18) ^ ((x) >> 3))
#define g_1(x) (rotr32((x), 17) ^ rotr32((x), 19) ^ ((x) >> 10))
#define k_0 k256
static const uint32_t k256[64] = {
0X428A2F98, 0X71374491, 0XB5C0FBCF, 0XE9B5DBA5,
0X3956C25B, 0X59F111F1, 0X923F82A4, 0XAB1C5ED5,
0XD807AA98, 0X12835B01, 0X243185BE, 0X550C7DC3,
0X72BE5D74, 0X80DEB1FE, 0X9BDC06A7, 0XC19BF174,
0XE49B69C1, 0XEFBE4786, 0X0FC19DC6, 0X240CA1CC,
0X2DE92C6F, 0X4A7484AA, 0X5CB0A9DC, 0X76F988DA,
0X983E5152, 0XA831C66D, 0XB00327C8, 0XBF597FC7,
0XC6E00BF3, 0XD5A79147, 0X06CA6351, 0X14292967,
0X27B70A85, 0X2E1B2138, 0X4D2C6DFC, 0X53380D13,
0X650A7354, 0X766A0ABB, 0X81C2C92E, 0X92722C85,
0XA2BFE8A1, 0XA81A664B, 0XC24B8B70, 0XC76C51A3,
0XD192E819, 0XD6990624, 0XF40E3585, 0X106AA070,
0X19A4C116, 0X1E376C08, 0X2748774C, 0X34B0BCB5,
0X391C0CB3, 0X4ED8AA4A, 0X5B9CCA4F, 0X682E6FF3,
0X748F82EE, 0X78A5636F, 0X84C87814, 0X8CC70208,
0X90BEFFFA, 0XA4506CEB, 0XBEF9A3F7, 0XC67178F2,
0X428A2F98, 0X71374491, 0XB5C0FBCF, 0XE9B5DBA5, 0X3956C25B, 0X59F111F1, 0X923F82A4, 0XAB1C5ED5,
0XD807AA98, 0X12835B01, 0X243185BE, 0X550C7DC3, 0X72BE5D74, 0X80DEB1FE, 0X9BDC06A7, 0XC19BF174,
0XE49B69C1, 0XEFBE4786, 0X0FC19DC6, 0X240CA1CC, 0X2DE92C6F, 0X4A7484AA, 0X5CB0A9DC, 0X76F988DA,
0X983E5152, 0XA831C66D, 0XB00327C8, 0XBF597FC7, 0XC6E00BF3, 0XD5A79147, 0X06CA6351, 0X14292967,
0X27B70A85, 0X2E1B2138, 0X4D2C6DFC, 0X53380D13, 0X650A7354, 0X766A0ABB, 0X81C2C92E, 0X92722C85,
0XA2BFE8A1, 0XA81A664B, 0XC24B8B70, 0XC76C51A3, 0XD192E819, 0XD6990624, 0XF40E3585, 0X106AA070,
0X19A4C116, 0X1E376C08, 0X2748774C, 0X34B0BCB5, 0X391C0CB3, 0X4ED8AA4A, 0X5B9CCA4F, 0X682E6FF3,
0X748F82EE, 0X78A5636F, 0X84C87814, 0X8CC70208, 0X90BEFFFA, 0XA4506CEB, 0XBEF9A3F7, 0XC67178F2,
};
void
sha256_process (sha256_context *ctx)
{
uint32_t i;
uint32_t *p = ctx->wbuf;
uint32_t v[8];
void sha256_process(sha256_context* ctx) {
uint32_t i;
uint32_t* p = ctx->wbuf;
uint32_t v[8];
memcpy (v, ctx->state, 8 * sizeof (uint32_t));
memcpy(v, ctx->state, 8 * sizeof(uint32_t));
v_cycle0 ( 0); v_cycle0 ( 1); v_cycle0 ( 2); v_cycle0 ( 3);
v_cycle0 ( 4); v_cycle0 ( 5); v_cycle0 ( 6); v_cycle0 ( 7);
v_cycle0 ( 8); v_cycle0 ( 9); v_cycle0 (10); v_cycle0 (11);
v_cycle0 (12); v_cycle0 (13); v_cycle0 (14); v_cycle0 (15);
v_cycle0(0);
v_cycle0(1);
v_cycle0(2);
v_cycle0(3);
v_cycle0(4);
v_cycle0(5);
v_cycle0(6);
v_cycle0(7);
v_cycle0(8);
v_cycle0(9);
v_cycle0(10);
v_cycle0(11);
v_cycle0(12);
v_cycle0(13);
v_cycle0(14);
v_cycle0(15);
for (i = 16; i < 64; i += 16)
{
v_cycle ( 0, i); v_cycle ( 1, i); v_cycle ( 2, i); v_cycle ( 3, i);
v_cycle ( 4, i); v_cycle ( 5, i); v_cycle ( 6, i); v_cycle ( 7, i);
v_cycle ( 8, i); v_cycle ( 9, i); v_cycle (10, i); v_cycle (11, i);
v_cycle (12, i); v_cycle (13, i); v_cycle (14, i); v_cycle (15, i);
for(i = 16; i < 64; i += 16) {
v_cycle(0, i);
v_cycle(1, i);
v_cycle(2, i);
v_cycle(3, i);
v_cycle(4, i);
v_cycle(5, i);
v_cycle(6, i);
v_cycle(7, i);
v_cycle(8, i);
v_cycle(9, i);
v_cycle(10, i);
v_cycle(11, i);
v_cycle(12, i);
v_cycle(13, i);
v_cycle(14, i);
v_cycle(15, i);
}
ctx->state[0] += v[0];
ctx->state[1] += v[1];
ctx->state[2] += v[2];
ctx->state[3] += v[3];
ctx->state[4] += v[4];
ctx->state[5] += v[5];
ctx->state[6] += v[6];
ctx->state[7] += v[7];
ctx->state[0] += v[0];
ctx->state[1] += v[1];
ctx->state[2] += v[2];
ctx->state[3] += v[3];
ctx->state[4] += v[4];
ctx->state[5] += v[5];
ctx->state[6] += v[6];
ctx->state[7] += v[7];
}
void
sha256_update (sha256_context *ctx, const unsigned char *input,
unsigned int ilen)
{
uint32_t left = (ctx->total[0] & SHA256_MASK);
uint32_t fill = SHA256_BLOCK_SIZE - left;
void sha256_update(sha256_context* ctx, const unsigned char* input, unsigned int ilen) {
uint32_t left = (ctx->total[0] & SHA256_MASK);
uint32_t fill = SHA256_BLOCK_SIZE - left;
ctx->total[0] += ilen;
if (ctx->total[0] < ilen)
ctx->total[1]++;
ctx->total[0] += ilen;
if(ctx->total[0] < ilen) ctx->total[1]++;
while (ilen >= fill)
{
memcpy (((unsigned char*)ctx->wbuf) + left, input, fill);
sha256_process (ctx);
input += fill;
ilen -= fill;
left = 0;
fill = SHA256_BLOCK_SIZE;
while(ilen >= fill) {
memcpy(((unsigned char*)ctx->wbuf) + left, input, fill);
sha256_process(ctx);
input += fill;
ilen -= fill;
left = 0;
fill = SHA256_BLOCK_SIZE;
}
memcpy (((unsigned char*)ctx->wbuf) + left, input, ilen);
memcpy(((unsigned char*)ctx->wbuf) + left, input, ilen);
}
void
sha256_finish (sha256_context *ctx, unsigned char output[32])
{
uint32_t last = (ctx->total[0] & SHA256_MASK);
void sha256_finish(sha256_context* ctx, unsigned char output[32]) {
uint32_t last = (ctx->total[0] & SHA256_MASK);
ctx->wbuf[last >> 2] = __builtin_bswap32 (ctx->wbuf[last >> 2]);
ctx->wbuf[last >> 2] &= 0xffffff80 << (8 * (~last & 3));
ctx->wbuf[last >> 2] |= 0x00000080 << (8 * (~last & 3));
ctx->wbuf[last >> 2] = __builtin_bswap32 (ctx->wbuf[last >> 2]);
ctx->wbuf[last >> 2] = __builtin_bswap32(ctx->wbuf[last >> 2]);
ctx->wbuf[last >> 2] &= 0xffffff80 << (8 * (~last & 3));
ctx->wbuf[last >> 2] |= 0x00000080 << (8 * (~last & 3));
ctx->wbuf[last >> 2] = __builtin_bswap32(ctx->wbuf[last >> 2]);
if (last > SHA256_BLOCK_SIZE - 9)
{
if (last < 60)
ctx->wbuf[15] = 0;
sha256_process (ctx);
last = 0;
}
else
last = (last >> 2) + 1;
if(last > SHA256_BLOCK_SIZE - 9) {
if(last < 60) ctx->wbuf[15] = 0;
sha256_process(ctx);
last = 0;
} else
last = (last >> 2) + 1;
while (last < 14)
ctx->wbuf[last++] = 0;
while(last < 14) ctx->wbuf[last++] = 0;
ctx->wbuf[14] = __builtin_bswap32 ((ctx->total[0] >> 29) | (ctx->total[1] << 3));
ctx->wbuf[15] = __builtin_bswap32 (ctx->total[0] << 3);
sha256_process (ctx);
ctx->wbuf[14] = __builtin_bswap32((ctx->total[0] >> 29) | (ctx->total[1] << 3));
ctx->wbuf[15] = __builtin_bswap32(ctx->total[0] << 3);
sha256_process(ctx);
memcpy_output_bswap32 (output, ctx->state);
memset (ctx, 0, sizeof (sha256_context));
memcpy_output_bswap32(output, ctx->state);
memset(ctx, 0, sizeof(sha256_context));
}
static const uint32_t initial_state[8] =
{
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
};
static const uint32_t initial_state[8] = {
0x6a09e667,
0xbb67ae85,
0x3c6ef372,
0xa54ff53a,
0x510e527f,
0x9b05688c,
0x1f83d9ab,
0x5be0cd19};
void
sha256_start (sha256_context *ctx)
{
ctx->total[0] = ctx->total[1] = 0;
memcpy (ctx->state, initial_state, 8 * sizeof(uint32_t));
void sha256_start(sha256_context* ctx) {
ctx->total[0] = ctx->total[1] = 0;
memcpy(ctx->state, initial_state, 8 * sizeof(uint32_t));
}
void
sha256 (const unsigned char *input, unsigned int ilen,
unsigned char output[32])
{
sha256_context ctx;
void sha256(const unsigned char* input, unsigned int ilen, unsigned char output[32]) {
sha256_context ctx;
sha256_start (&ctx);
sha256_update (&ctx, input, ilen);
sha256_finish (&ctx, output);
sha256_start(&ctx);
sha256_update(&ctx, input, ilen);
sha256_finish(&ctx, output);
}

25
lib/toolbox/sha256.h
View File

@@ -1,17 +1,14 @@
#define SHA256_DIGEST_SIZE 32
#define SHA256_BLOCK_SIZE 64
#define SHA256_DIGEST_SIZE 32
#define SHA256_BLOCK_SIZE 64
typedef struct
{
uint32_t total[2];
uint32_t state[8];
uint32_t wbuf[16];
typedef struct {
uint32_t total[2];
uint32_t state[8];
uint32_t wbuf[16];
} sha256_context;
void sha256 (const unsigned char *input, unsigned int ilen,
unsigned char output[32]);
void sha256_start (sha256_context *ctx);
void sha256_finish (sha256_context *ctx, unsigned char output[32]);
void sha256_update (sha256_context *ctx, const unsigned char *input,
unsigned int ilen);
void sha256_process (sha256_context *ctx);
void sha256(const unsigned char* input, unsigned int ilen, unsigned char output[32]);
void sha256_start(sha256_context* ctx);
void sha256_finish(sha256_context* ctx, unsigned char output[32]);
void sha256_update(sha256_context* ctx, const unsigned char* input, unsigned int ilen);
void sha256_process(sha256_context* ctx);

22
lib/toolbox/version.c
View File

@@ -1,25 +1,24 @@
#include "version.h"
struct Version {
const char* git_hash;
const char* git_branch;
const char* git_branch_num;
const char* build_date;
const char* version;
const char* git_hash;
const char* git_branch;
const char* git_branch_num;
const char* build_date;
const char* version;
const uint8_t target;
};
/* version of current running firmware (bootloader/flipper) */
static const Version version = {
.git_hash = GIT_COMMIT,
.git_branch = GIT_BRANCH,
.git_hash = GIT_COMMIT,
.git_branch = GIT_BRANCH,
.git_branch_num = GIT_BRANCH_NUM,
.build_date = BUILD_DATE,
.version = VERSION,
.target = TARGET,
.build_date = BUILD_DATE,
.version = VERSION,
.target = TARGET,
};
const Version* version_get(void) {
return &version;
}
@@ -47,4 +46,3 @@ const char* version_get_version(const Version* v) {
const uint8_t version_get_target(const Version* v) {
return v ? v->target : version.target;
}

1
lib/toolbox/version.h
View File

@@ -75,4 +75,3 @@ const uint8_t version_get_target(const Version* v);
#ifdef __cplusplus
}
#endif