github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-21 13:53:55 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

fix const params, lessen variable scope and fixing func arguments names

Browse source
This commit is contained in:
iceman1001 2024-05-14 11:10:12 +02:00
commit 3430e20459
3 changed files with 129 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

65
common/bruteforce.c
View file

@ -63,13 +63,15 @@ int bf_generator_set_charset(generator_context_t *ctx, uint8_t charsets) {
int bf_generate(generator_context_t *ctx) {
switch (ctx->mode) {
case BF_MODE_RANGE:
case BF_MODE_RANGE: {
return _bf_generate_mode_range(ctx);
case BF_MODE_CHARSET:
}
case BF_MODE_CHARSET: {
return _bf_generate_mode_charset(ctx);
case BF_MODE_SMART:
}
case BF_MODE_SMART: {
return _bf_generate_mode_smart(ctx);
}
}
return BF_GENERATOR_ERROR;
@ -81,23 +83,27 @@ int bf_generate(generator_context_t *ctx) {
// returns -1 if incrementing reaches its end
int bf_array_increment(uint8_t *data, uint8_t data_len, uint8_t modulo) {
uint8_t prev_value;
// check if we reached max value already
uint8_t i;
for (i = 0; i < data_len; i++)
if (data[i] < modulo - 1)
for (i = 0; i < data_len; i++) {
if (data[i] < modulo - 1) {
break;
}
}
if (i == data_len)
if (i == data_len) {
return -1;
}
for (uint8_t pos = data_len - 1;; pos--) {
prev_value = ++data[pos];
uint8_t prev_value = ++data[pos];
data[pos] = data[pos] % modulo;
if (prev_value == data[pos])
if (prev_value == data[pos]) {
return 0;
else if (pos == 0) {
} else if (pos == 0) {
// we cannot carryover to next byte
// with the max value check in place before, we should not reach this place
return -1;
@ -108,12 +114,12 @@ int bf_array_increment(uint8_t *data, uint8_t data_len, uint8_t modulo) {
}
// get current key casted to 32 bit
uint32_t bf_get_key32(generator_context_t *ctx) {
uint32_t bf_get_key32(const generator_context_t *ctx) {
return ctx->current_key & 0xFFFFFFFF;
}
// get current key casted to 48 bit
uint64_t bf_get_key48(generator_context_t *ctx) {
uint64_t bf_get_key48(const generator_context_t *ctx) {
return ctx->current_key & 0xFFFFFFFFFFFF;
}
@ -127,8 +133,9 @@ void bf_generator_clear(generator_context_t *ctx) {
int _bf_generate_mode_range(generator_context_t *ctx) {
if (ctx->key_length != BF_KEY_SIZE_32 && ctx->key_length != BF_KEY_SIZE_48)
if (ctx->key_length != BF_KEY_SIZE_32 && ctx->key_length != BF_KEY_SIZE_48) {
return BF_GENERATOR_ERROR;
}
if (ctx->current_key >= ctx->range_high) {
return BF_GENERATOR_END;
@ -152,8 +159,9 @@ int _bf_generate_mode_charset(generator_context_t *ctx) {
return BF_GENERATOR_ERROR;
}
if (ctx->flag1)
if (ctx->flag1) {
return BF_GENERATOR_END;
}
uint8_t key_byte = 0;
ctx->current_key = 0;
@ -162,32 +170,35 @@ int _bf_generate_mode_charset(generator_context_t *ctx) {
ctx->current_key |= (uint64_t) ctx->charset[ctx->pos[key_byte]] << ((ctx->key_length - key_byte - 1) * 8);
}
if (bf_array_increment(ctx->pos, ctx->key_length, ctx->charset_length) == -1)
if (bf_array_increment(ctx->pos, ctx->key_length, ctx->charset_length) == -1) {
// set flag1 to emit value last time and end generation on next call
ctx->flag1 = true;
}
return BF_GENERATOR_NEXT;
}
int _bf_generate_mode_smart(generator_context_t *ctx) {
int ret;
while (1) {
if (smart_generators[ctx->smart_mode_stage] == NULL)
if (smart_generators[ctx->smart_mode_stage] == NULL) {
return BF_GENERATOR_END;
}
ret = smart_generators[ctx->smart_mode_stage](ctx);
int ret = smart_generators[ctx->smart_mode_stage](ctx);
switch (ret) {
case BF_GENERATOR_NEXT:
case BF_GENERATOR_NEXT: {
return ret;
case BF_GENERATOR_ERROR:
}
case BF_GENERATOR_ERROR: {
return ret;
case BF_GENERATOR_END:
}
case BF_GENERATOR_END: {
ctx->smart_mode_stage++;
bf_generator_clear(ctx);
continue;
}
}
}
}
@ -197,8 +208,9 @@ int smart_generator_byte_repeat(generator_context_t *ctx) {
// key consists of repeated single byte
uint32_t current_byte = ctx->counter1;
if (current_byte > 0xFF)
if (current_byte > 0xFF) {
return BF_GENERATOR_END;
}
ctx->current_key = 0;
@ -213,8 +225,9 @@ int smart_generator_msb_byte_only(generator_context_t *ctx) {
// key of one byte (most significant one) and all others being zero
uint32_t current_byte = ctx->counter1;
if (current_byte > 0xFF)
if (current_byte > 0xFF) {
return BF_GENERATOR_END;
}
ctx->current_key = (uint64_t)current_byte << ((ctx->key_length - 1) * 8);