(property: P, value: Props[P]): void; - /** - * Check if property is available - * @param name Name of the property - */ - hasProperty(name: string): boolean; } export declare class ViewFactory> { diff --git a/applications/system/js_app/types/i2c/index.d.ts b/applications/system/js_app/types/i2c/index.d.ts new file mode 100644 index 000000000..ea0a640cb --- /dev/null +++ b/applications/system/js_app/types/i2c/index.d.ts @@ -0,0 +1,31 @@ +/** + * @brief Check if there is an I2C device ready on the bus + * @param address The device address to check + * @param timeout Timeout in milliseconds + */ +export declare function isDeviceReady(address: number, timeout?: number): boolean; + +/** + * @brief Write data to I2C device and return success status + * @param address The device address to write to + * @param data The data to write to the device + * @param timeout Timeout in milliseconds + */ +export declare function write(address: number, data: number[] | ArrayBuffer, timeout?: number): boolean; + +/** + * @brief Read data from I2C device or return undefined on failure + * @param address The device address to read from + * @param length How many bytes to read + * @param timeout Timeout in milliseconds + */ +export declare function read(address: number, length: number, timeout?: number): ArrayBuffer | undefined; + +/** + * @brief Write data then read from I2C device or return undefined on failure + * @param address The device address to talk to + * @param writeData The data to write to the device + * @param readLength How many bytes to read + * @param timeout Timeout in milliseconds + */ +export declare function writeRead(address: number, writeData: number[] | ArrayBuffer, readLength: number, timeout?: number): ArrayBuffer | undefined; diff --git a/applications/system/js_app/types/math/index.d.ts b/applications/system/js_app/types/math/index.d.ts index 25abca4af..4924eea7e 100644 --- a/applications/system/js_app/types/math/index.d.ts +++ b/applications/system/js_app/types/math/index.d.ts @@ -1,3 +1,4 @@ +export function isEqual(a: number, b: number, tolerance: number): boolean; export function abs(n: number): number; export function acos(n: number): number; export function acosh(n: number): number; @@ -12,6 +13,7 @@ export function clz32(n: number): number; export function cos(n: number): number; export function exp(n: number): number; export function floor(n: number): number; +export function log(n: number): number; export function max(n: number, m: number): number; export function min(n: number, m: number): number; export function pow(n: number, m: number): number; @@ -21,4 +23,5 @@ export function sin(n: number): number; export function sqrt(n: number): number; export function trunc(n: number): number; declare const PI: number; +declare const E: number; declare const EPSILON: number; diff --git a/applications/system/js_app/types/spi/index.d.ts b/applications/system/js_app/types/spi/index.d.ts new file mode 100644 index 000000000..8d72bc29c --- /dev/null +++ b/applications/system/js_app/types/spi/index.d.ts @@ -0,0 +1,30 @@ +/** + * @brief Acquire SPI bus + */ +export declare function acquire(): void; + +/** + * @brief Release SPI bus + */ +export declare function release(): void; + +/** + * @brief Write data to SPI bus and return success status + * @param data The data to write + * @param timeout Timeout in milliseconds + */ +export declare function write(data: number[] | ArrayBuffer, timeout?: number): boolean; + +/** + * @brief Read data from SPI bus or return undefined on failure + * @param length How many bytes to read + * @param timeout Timeout in milliseconds + */ +export declare function read(length: number, timeout?: number): ArrayBuffer | undefined; + +/** + * @brief Write and read data on SPI bus or return undefined on failure + * @param data The data to write, its length also indicates how many bytes will be read + * @param timeout Timeout in milliseconds + */ +export declare function writeRead(data: number[] | ArrayBuffer, timeout?: number): ArrayBuffer | undefined; diff --git a/assets/protobuf b/assets/protobuf index b7d588169..c255d71a9 160000 --- a/assets/protobuf +++ b/assets/protobuf @@ -1 +1 @@ -Subproject commit b7d5881690298de836df6305d4c71f96d5d34c61 +Subproject commit c255d71a90af202515deb7aaa51685d45a196152 diff --git a/documentation/doxygen/index.dox b/documentation/doxygen/index.dox index 7bd9024a1..9587afd8b 100644 --- a/documentation/doxygen/index.dox +++ b/documentation/doxygen/index.dox @@ -1,7 +1,8 @@ /** -@mainpage Overview +@mainpage notitle +## Welcome to Flipper Developer Documentation! -Welcome to the Flipper Developer Documentation! +--- This documentation is intended for developers interested in modifying the Flipper Zero firmware, creating Apps and JavaScript programs, or working on external hardware modules for the device. diff --git a/documentation/js/js_math.md b/documentation/js/js_math.md index 12dae8fb3..ca16a9111 100644 --- a/documentation/js/js_math.md +++ b/documentation/js/js_math.md @@ -223,7 +223,7 @@ math.floor(45.05); // 45 math.floor(45.95); // 45 ``` -## is_equal +## isEqual Return true if the difference between numbers `a` and `b` is less than the specified parameter `e`. ### Parameters @@ -236,8 +236,8 @@ True if the difference between numbers `a` and `b` is less than the specified pa ### Example ```js -math.is_equal(1.4, 1.6, 0.2); // false -math.is_equal(3.556, 3.555, 0.01); // true +math.isEqual(1.4, 1.6, 0.2); // false +math.isEqual(3.556, 3.555, 0.01); // true ``` ## max diff --git a/lib/digital_signal/digital_sequence.c b/lib/digital_signal/digital_sequence.c index f93ce6d95..14cb3aab2 100644 --- a/lib/digital_signal/digital_sequence.c +++ b/lib/digital_signal/digital_sequence.c @@ -15,6 +15,9 @@ * Example: * ./fbt --extra-define=DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN=gpio_ext_pb3 */ +#ifdef DIGITAL_SIGNAL_DEBUG_OUTPUT_PIN +#include +#endif #define TAG "DigitalSequence" diff --git a/lib/mjs/mjs_exec.c b/lib/mjs/mjs_exec.c index 265e7d5c3..8fdb2d7e5 100644 --- a/lib/mjs/mjs_exec.c +++ b/lib/mjs/mjs_exec.c @@ -452,6 +452,12 @@ static int getprop_builtin_string( } else if(strcmp(name, "slice") == 0) { *res = mjs_mk_foreign_func(mjs, (mjs_func_ptr_t)mjs_string_slice); return 1; + } else if(strcmp(name, "toUpperCase") == 0) { + *res = mjs_mk_foreign_func(mjs, (mjs_func_ptr_t)mjs_string_to_upper_case); + return 1; + } else if(strcmp(name, "toLowerCase") == 0) { + *res = mjs_mk_foreign_func(mjs, (mjs_func_ptr_t)mjs_string_to_lower_case); + return 1; } else if(isnum) { /* * string subscript: return a new one-byte string if the index @@ -469,6 +475,22 @@ static int getprop_builtin_string( return 0; } +static int getprop_builtin_number( + struct mjs* mjs, + mjs_val_t val, + const char* name, + size_t name_len, + mjs_val_t* res) { + if(strcmp(name, "toString") == 0) { + *res = mjs_mk_foreign_func(mjs, (mjs_func_ptr_t)mjs_number_to_string); + return 1; + } + + (void)val; + (void)name_len; + return 0; +} + static int getprop_builtin_array( struct mjs* mjs, mjs_val_t val, @@ -583,6 +605,8 @@ static int getprop_builtin(struct mjs* mjs, mjs_val_t val, mjs_val_t name, mjs_v } else if(s != NULL && n == 5 && strncmp(s, "apply", n) == 0) { *res = mjs_mk_foreign_func(mjs, (mjs_func_ptr_t)mjs_apply_); handled = 1; + } else if(mjs_is_number(val)) { + handled = getprop_builtin_number(mjs, val, s, n, res); } else if(mjs_is_array(val)) { handled = getprop_builtin_array(mjs, val, s, n, res); } else if(mjs_is_foreign(val)) { diff --git a/lib/mjs/mjs_primitive.c b/lib/mjs/mjs_primitive.c index b63a268e5..e73ae892d 100644 --- a/lib/mjs/mjs_primitive.c +++ b/lib/mjs/mjs_primitive.c @@ -6,6 +6,8 @@ #include "mjs_core.h" #include "mjs_internal.h" #include "mjs_primitive.h" +#include "mjs_string_public.h" +#include "mjs_util.h" mjs_val_t mjs_mk_null(void) { return MJS_NULL; @@ -158,3 +160,31 @@ MJS_PRIVATE void mjs_op_isnan(struct mjs* mjs) { mjs_return(mjs, ret); } + +MJS_PRIVATE void mjs_number_to_string(struct mjs* mjs) { + mjs_val_t ret = MJS_UNDEFINED; + mjs_val_t base_v = MJS_UNDEFINED; + int32_t base = 10; + int32_t num; + + /* get number from `this` */ + if(!mjs_check_arg(mjs, -1 /*this*/, "this", MJS_TYPE_NUMBER, NULL)) { + goto clean; + } + num = mjs_get_int32(mjs, mjs->vals.this_obj); + + if(mjs_nargs(mjs) >= 1) { + /* get base from arg 0 */ + if(!mjs_check_arg(mjs, 0, "base", MJS_TYPE_NUMBER, &base_v)) { + goto clean; + } + base = mjs_get_int(mjs, base_v); + } + + char tmp_str[] = "-2147483648"; + itoa(num, tmp_str, base); + ret = mjs_mk_string(mjs, tmp_str, ~0, true); + +clean: + mjs_return(mjs, ret); +} diff --git a/lib/mjs/mjs_primitive.h b/lib/mjs/mjs_primitive.h index 6d6f91785..f1c3c8220 100644 --- a/lib/mjs/mjs_primitive.h +++ b/lib/mjs/mjs_primitive.h @@ -34,6 +34,11 @@ MJS_PRIVATE void* get_ptr(mjs_val_t v); */ MJS_PRIVATE void mjs_op_isnan(struct mjs* mjs); +/* + * Implementation for JS Number.toString() + */ +MJS_PRIVATE void mjs_number_to_string(struct mjs* mjs); + #if defined(__cplusplus) } #endif /* __cplusplus */ diff --git a/lib/mjs/mjs_string.c b/lib/mjs/mjs_string.c index f74bf1074..f771ff4ea 100644 --- a/lib/mjs/mjs_string.c +++ b/lib/mjs/mjs_string.c @@ -286,6 +286,41 @@ MJS_PRIVATE mjs_val_t s_concat(struct mjs* mjs, mjs_val_t a, mjs_val_t b) { return res; } +MJS_PRIVATE void mjs_string_to_case(struct mjs* mjs, bool upper) { + mjs_val_t ret = MJS_UNDEFINED; + size_t size; + const char* s = NULL; + + /* get string from `this` */ + if(!mjs_check_arg(mjs, -1 /*this*/, "this", MJS_TYPE_STRING, NULL)) { + goto clean; + } + s = mjs_get_string(mjs, &mjs->vals.this_obj, &size); + + if(size == 0) { + ret = mjs_mk_string(mjs, "", 0, 1); + goto clean; + } + + char* tmp = malloc(size); + for(size_t i = 0; i < size; i++) { + tmp[i] = upper ? toupper(s[i]) : tolower(s[i]); + } + ret = mjs_mk_string(mjs, tmp, size, 1); + free(tmp); + +clean: + mjs_return(mjs, ret); +} + +MJS_PRIVATE void mjs_string_to_lower_case(struct mjs* mjs) { + mjs_string_to_case(mjs, false); +} + +MJS_PRIVATE void mjs_string_to_upper_case(struct mjs* mjs) { + mjs_string_to_case(mjs, true); +} + MJS_PRIVATE void mjs_string_slice(struct mjs* mjs) { int nargs = mjs_nargs(mjs); mjs_val_t ret = mjs_mk_number(mjs, 0); diff --git a/lib/mjs/mjs_string.h b/lib/mjs/mjs_string.h index ba6869b62..f0801f1a4 100644 --- a/lib/mjs/mjs_string.h +++ b/lib/mjs/mjs_string.h @@ -33,6 +33,8 @@ MJS_PRIVATE void embed_string( MJS_PRIVATE void mjs_mkstr(struct mjs* mjs); +MJS_PRIVATE void mjs_string_to_lower_case(struct mjs* mjs); +MJS_PRIVATE void mjs_string_to_upper_case(struct mjs* mjs); MJS_PRIVATE void mjs_string_slice(struct mjs* mjs); MJS_PRIVATE void mjs_string_index_of(struct mjs* mjs); MJS_PRIVATE void mjs_string_char_code_at(struct mjs* mjs); diff --git a/lib/nfc/protocols/mf_classic/mf_classic.c b/lib/nfc/protocols/mf_classic/mf_classic.c index 4f92201e3..b1c5c20c9 100644 --- a/lib/nfc/protocols/mf_classic/mf_classic.c +++ b/lib/nfc/protocols/mf_classic/mf_classic.c @@ -543,6 +543,22 @@ void mf_classic_set_key_not_found( } } +MfClassicKey + mf_classic_get_key(const MfClassicData* data, uint8_t sector_num, MfClassicKeyType key_type) { + furi_check(data); + furi_check(sector_num < mf_classic_get_total_sectors_num(data->type)); + furi_check(key_type == MfClassicKeyTypeA || key_type == MfClassicKeyTypeB); + + const MfClassicSectorTrailer* sector_trailer = + mf_classic_get_sector_trailer_by_sector(data, sector_num); + + if(key_type == MfClassicKeyTypeA) { + return sector_trailer->key_a; + } else { + return sector_trailer->key_b; + } +} + bool mf_classic_is_block_read(const MfClassicData* data, uint8_t block_num) { furi_check(data); diff --git a/lib/nfc/protocols/mf_classic/mf_classic.h b/lib/nfc/protocols/mf_classic/mf_classic.h index 38c3e9ba7..6ae7a623e 100644 --- a/lib/nfc/protocols/mf_classic/mf_classic.h +++ b/lib/nfc/protocols/mf_classic/mf_classic.h @@ -213,6 +213,9 @@ void mf_classic_set_key_not_found( uint8_t sector_num, MfClassicKeyType key_type); +MfClassicKey + mf_classic_get_key(const MfClassicData* data, uint8_t sector_num, MfClassicKeyType key_type); + bool mf_classic_is_block_read(const MfClassicData* data, uint8_t block_num); void mf_classic_set_block_read(MfClassicData* data, uint8_t block_num, MfClassicBlock* block_data); diff --git a/lib/nfc/protocols/mf_classic/mf_classic_poller.c b/lib/nfc/protocols/mf_classic/mf_classic_poller.c index 7417322e9..edfdb2a95 100644 --- a/lib/nfc/protocols/mf_classic/mf_classic_poller.c +++ b/lib/nfc/protocols/mf_classic/mf_classic_poller.c @@ -8,9 +8,9 @@ // TODO: Buffer writes for Hardnested, set state to Log when finished and sum property matches // TODO: Store target key in CUID dictionary -// TODO: Fix rare nested_target_key 64 bug // TODO: Dead code for malloc returning NULL? // TODO: Auth1 static encrypted exists (rare) +// TODO: Use keys found by NFC plugins, cached keys #define MF_CLASSIC_MAX_BUFF_SIZE (64) @@ -1663,7 +1663,7 @@ NfcCommand mf_classic_poller_handler_nested_dict_attack(MfClassicPoller* instanc "Found key candidate %06llx", bit_lib_bytes_to_num_be(key_candidate->data, sizeof(MfClassicKey))); dict_attack_ctx->current_key = *key_candidate; - dict_attack_ctx->reuse_key_sector = (target_block / 4); + dict_attack_ctx->reuse_key_sector = target_sector; dict_attack_ctx->current_key_type = target_key_type; free(key_candidate); break; @@ -1780,7 +1780,7 @@ NfcCommand mf_classic_poller_handler_nested_log(MfClassicPoller* instance) { bool mf_classic_nested_is_target_key_found(MfClassicPoller* instance, bool is_dict_attack) { MfClassicPollerDictAttackContext* dict_attack_ctx = &instance->mode_ctx.dict_attack_ctx; bool is_weak = dict_attack_ctx->prng_type == MfClassicPrngTypeWeak; - uint8_t nested_target_key = dict_attack_ctx->nested_target_key; + uint16_t nested_target_key = dict_attack_ctx->nested_target_key; MfClassicKeyType target_key_type; uint8_t target_sector; @@ -1818,12 +1818,13 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance bool initial_dict_attack_iter = false; if(dict_attack_ctx->nested_phase == MfClassicNestedPhaseNone) { dict_attack_ctx->auth_passed = true; - dict_attack_ctx->nested_known_key = dict_attack_ctx->current_key; bool backdoor_present = (dict_attack_ctx->backdoor != MfClassicBackdoorNone); if(!(backdoor_present)) { for(uint8_t sector = 0; sector < instance->sectors_total; sector++) { for(uint8_t key_type = 0; key_type < 2; key_type++) { if(mf_classic_is_key_found(instance->data, sector, key_type)) { + dict_attack_ctx->nested_known_key = + mf_classic_get_key(instance->data, sector, key_type); dict_attack_ctx->nested_known_key_sector = sector; dict_attack_ctx->nested_known_key_type = key_type; break; @@ -1832,6 +1833,7 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance } dict_attack_ctx->nested_phase = MfClassicNestedPhaseAnalyzePRNG; } else { + dict_attack_ctx->nested_known_key = dict_attack_ctx->current_key; dict_attack_ctx->nested_known_key_sector = 0; dict_attack_ctx->nested_known_key_type = MfClassicKeyTypeA; dict_attack_ctx->prng_type = MfClassicPrngTypeWeak; @@ -1879,9 +1881,10 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance uint16_t dict_target_key_max = (dict_attack_ctx->prng_type == MfClassicPrngTypeWeak) ? (instance->sectors_total * 2) : (instance->sectors_total * 16); - if(dict_attack_ctx->nested_phase == MfClassicNestedPhaseDictAttackResume) { + if(dict_attack_ctx->nested_phase == MfClassicNestedPhaseDictAttackVerify) { if(!(mf_classic_nested_is_target_key_found(instance, true)) && (dict_attack_ctx->nested_nonce.count > 0)) { + dict_attack_ctx->nested_phase = MfClassicNestedPhaseDictAttackResume; instance->state = MfClassicPollerStateNestedDictAttack; return command; } else { @@ -1896,7 +1899,8 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance dict_attack_ctx->nested_phase = MfClassicNestedPhaseDictAttack; } } - if((dict_attack_ctx->nested_phase == MfClassicNestedPhaseDictAttack) && + if((dict_attack_ctx->nested_phase == MfClassicNestedPhaseDictAttack || + dict_attack_ctx->nested_phase == MfClassicNestedPhaseDictAttackResume) && (dict_attack_ctx->nested_target_key < dict_target_key_max)) { bool is_last_iter_for_hard_key = ((!is_weak) && ((dict_attack_ctx->nested_target_key % 8) == 7)); @@ -1920,11 +1924,14 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance NULL; } if((is_weak || is_last_iter_for_hard_key) && dict_attack_ctx->nested_nonce.count > 0) { - // Key reuse - dict_attack_ctx->nested_phase = MfClassicNestedPhaseDictAttackResume; + // Key verify and reuse + dict_attack_ctx->nested_phase = MfClassicNestedPhaseDictAttackVerify; dict_attack_ctx->auth_passed = false; instance->state = MfClassicPollerStateKeyReuseStartNoOffset; return command; + } else if(dict_attack_ctx->nested_phase == MfClassicNestedPhaseDictAttackResume) { + dict_attack_ctx->nested_phase = MfClassicNestedPhaseDictAttack; + dict_attack_ctx->auth_passed = true; } if(!(dict_attack_ctx->auth_passed)) { dict_attack_ctx->attempt_count++; @@ -2004,9 +2011,7 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance } uint16_t nonce_collect_key_max; if(dict_attack_ctx->prng_type == MfClassicPrngTypeWeak) { - nonce_collect_key_max = dict_attack_ctx->static_encrypted ? - ((instance->sectors_total * 4) - 2) : - (instance->sectors_total * 4); + nonce_collect_key_max = instance->sectors_total * 4; } else { nonce_collect_key_max = instance->sectors_total * 2; } @@ -2047,30 +2052,6 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance dict_attack_ctx->attempt_count = 0; } dict_attack_ctx->auth_passed = true; - if(!(dict_attack_ctx->current_key_checked)) { - dict_attack_ctx->current_key_checked = true; - - // Check if the nested target key is a known key - if(mf_classic_nested_is_target_key_found(instance, false)) { - // Continue to next key - if(!(dict_attack_ctx->static_encrypted)) { - dict_attack_ctx->nested_target_key++; - dict_attack_ctx->current_key_checked = false; - } - instance->state = MfClassicPollerStateNestedController; - return command; - } - - // If it is not a known key, we'll need to calibrate for static encrypted backdoored tags - if((dict_attack_ctx->backdoor == MfClassicBackdoorAuth3) && - (dict_attack_ctx->nested_target_key < nonce_collect_key_max) && - !(recalibrated)) { - dict_attack_ctx->calibrated = false; - dict_attack_ctx->nested_phase = MfClassicNestedPhaseRecalibrate; - instance->state = MfClassicPollerStateNestedController; - return command; - } - } // If we have tried to collect this nonce too many times, skip if((is_weak && (dict_attack_ctx->attempt_count >= MF_CLASSIC_NESTED_RETRY_MAXIMUM)) || @@ -2096,12 +2077,52 @@ NfcCommand mf_classic_poller_handler_nested_controller(MfClassicPoller* instance dict_attack_ctx->attempt_count = 0; } + FURI_LOG_D( + TAG, + "Nested target key: %u (max: %u)", + dict_attack_ctx->nested_target_key, + nonce_collect_key_max); + + if(!(dict_attack_ctx->current_key_checked)) { + if(dict_attack_ctx->nested_target_key == nonce_collect_key_max) { + // All nonces have been collected + FURI_LOG_D(TAG, "All nonces collected"); + instance->state = MfClassicPollerStateNestedController; + return command; + } + + dict_attack_ctx->current_key_checked = true; + + // Check if the nested target key is a known key + if(mf_classic_nested_is_target_key_found(instance, false)) { + // Continue to next key + if(!(dict_attack_ctx->static_encrypted)) { + dict_attack_ctx->nested_target_key++; + dict_attack_ctx->current_key_checked = false; + } + instance->state = MfClassicPollerStateNestedController; + return command; + } + + // If it is not a known key, we'll need to calibrate for static encrypted backdoored tags + if((dict_attack_ctx->backdoor == MfClassicBackdoorAuth3) && + (dict_attack_ctx->nested_target_key < nonce_collect_key_max) && + !(recalibrated)) { + dict_attack_ctx->calibrated = false; + dict_attack_ctx->nested_phase = MfClassicNestedPhaseRecalibrate; + instance->state = MfClassicPollerStateNestedController; + return command; + } + } + FURI_LOG_T(TAG, "Collecting a nonce"); + // Collect a nonce dict_attack_ctx->auth_passed = false; instance->state = MfClassicPollerStateNestedCollectNtEnc; return command; } } + dict_attack_ctx->nested_target_key = 0; dict_attack_ctx->nested_phase = MfClassicNestedPhaseFinished; instance->state = MfClassicPollerStateSuccess; return command; diff --git a/lib/nfc/protocols/mf_classic/mf_classic_poller.h b/lib/nfc/protocols/mf_classic/mf_classic_poller.h index 7dfd3b6ab..8efb931aa 100644 --- a/lib/nfc/protocols/mf_classic/mf_classic_poller.h +++ b/lib/nfc/protocols/mf_classic/mf_classic_poller.h @@ -52,14 +52,15 @@ typedef enum { * @brief MfClassic poller nested attack phase. */ typedef enum { - MfClassicNestedPhaseNone, - MfClassicNestedPhaseAnalyzePRNG, - MfClassicNestedPhaseDictAttack, - MfClassicNestedPhaseDictAttackResume, - MfClassicNestedPhaseCalibrate, - MfClassicNestedPhaseRecalibrate, - MfClassicNestedPhaseCollectNtEnc, - MfClassicNestedPhaseFinished, + MfClassicNestedPhaseNone, /**< No nested attack has taken place yet. */ + MfClassicNestedPhaseAnalyzePRNG, /**< Analyze nonces produced by the PRNG to determine if they fit a weak PRNG */ + MfClassicNestedPhaseDictAttack, /**< Search keys which match the expected PRNG properties and parity for collected nonces */ + MfClassicNestedPhaseDictAttackVerify, /**< Verify candidate keys by authenticating to the sector with the key */ + MfClassicNestedPhaseDictAttackResume, /**< Resume nested dictionary attack from the last tested (invalid) key */ + MfClassicNestedPhaseCalibrate, /**< Perform necessary calculations to recover the plaintext nonce during later collection phase (weak PRNG tags only) */ + MfClassicNestedPhaseRecalibrate, /**< Collect the next plaintext static encrypted nonce for backdoor static encrypted nonce nested attack */ + MfClassicNestedPhaseCollectNtEnc, /**< Log nonces collected during nested authentication for key recovery */ + MfClassicNestedPhaseFinished, /**< Nested attack has finished */ } MfClassicNestedPhase; /** diff --git a/lib/nfc/protocols/mf_classic/mf_classic_poller_i.c b/lib/nfc/protocols/mf_classic/mf_classic_poller_i.c index aac05748f..deccdbcda 100644 --- a/lib/nfc/protocols/mf_classic/mf_classic_poller_i.c +++ b/lib/nfc/protocols/mf_classic/mf_classic_poller_i.c @@ -5,7 +5,7 @@ #include -#define TAG "MfCLassicPoller" +#define TAG "MfClassicPoller" MfClassicError mf_classic_process_error(Iso14443_3aError error) { MfClassicError ret = MfClassicErrorNone; diff --git a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c index dca31f247..7d51f6c6e 100644 --- a/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c +++ b/lib/nfc/protocols/mf_ultralight/mf_ultralight_poller.c @@ -508,7 +508,7 @@ static NfcCommand mf_ultralight_poller_handler_read_pages(MfUltralightPoller* in if(instance->error == MfUltralightErrorNone) { if(start_page < instance->pages_total) { FURI_LOG_D(TAG, "Read page %d success", start_page); - instance->data->page[start_page] = data.page[start_page]; + instance->data->page[start_page] = data.page[0]; instance->pages_read++; instance->data->pages_read = instance->pages_read; } diff --git a/lib/subghz/protocols/keeloq.c b/lib/subghz/protocols/keeloq.c index 8db4d1120..b1dbb6f86 100644 --- a/lib/subghz/protocols/keeloq.c +++ b/lib/subghz/protocols/keeloq.c @@ -255,6 +255,9 @@ static bool subghz_protocol_keeloq_gen_data( } else if(strcmp(instance->manufacture_name, "Centurion") == 0) { decrypt = btn << 28 | (0x1CE) << 16 | instance->generic.cnt; // Centurion -> no serial in hop, uses fixed value 0x1CE - normal learning + } else if(strcmp(instance->manufacture_name, "Monarch") == 0) { + decrypt = btn << 28 | (0x100) << 16 | instance->generic.cnt; + // Monarch -> no serial in hop, uses fixed value 0x100 - normal learning } else if(strcmp(instance->manufacture_name, "Dea_Mio") == 0) { uint8_t first_disc_num = (instance->generic.serial >> 8) & 0xF; uint8_t result_disc = (0xC + (first_disc_num % 4)); @@ -430,12 +433,13 @@ static bool (strcmp(instance->manufacture_name, "Dea_Mio") == 0) || (strcmp(instance->manufacture_name, "NICE_MHOUSE") == 0)) { klq_last_custom_btn = 0xF; - } else if((strcmp(instance->manufacture_name, "FAAC_RC,XT") == 0)) { + } else if( + (strcmp(instance->manufacture_name, "FAAC_RC,XT") == 0) || + (strcmp(instance->manufacture_name, "Monarch") == 0) || + (strcmp(instance->manufacture_name, "NICE_Smilo") == 0)) { klq_last_custom_btn = 0xB; } else if((strcmp(instance->manufacture_name, "Novoferm") == 0)) { klq_last_custom_btn = 0x9; - } else if((strcmp(instance->manufacture_name, "NICE_Smilo") == 0)) { - klq_last_custom_btn = 0xB; } else if((strcmp(instance->manufacture_name, "EcoStar") == 0)) { klq_last_custom_btn = 0x6; } diff --git a/lib/subghz/protocols/protocol_items.c b/lib/subghz/protocols/protocol_items.c index c6a1c08f5..3ebb8b4f7 100644 --- a/lib/subghz/protocols/protocol_items.c +++ b/lib/subghz/protocols/protocol_items.c @@ -67,6 +67,7 @@ const SubGhzProtocol* subghz_protocol_registry_items[] = { &ws_protocol_kedsum_th, &ws_protocol_emose601x, &ws_protocol_acurite_5n1, + &ws_protocol_vauno_en8822c, &subghz_protocol_pocsag, &tpms_protocol_schrader_gg4, &subghz_protocol_bin_raw, diff --git a/lib/subghz/protocols/protocol_items.h b/lib/subghz/protocols/protocol_items.h index 48e72cc44..8fbbc9a82 100644 --- a/lib/subghz/protocols/protocol_items.h +++ b/lib/subghz/protocols/protocol_items.h @@ -68,6 +68,7 @@ #include "acurite_5n1.h" #include "solight_te44.h" #include "bresser_3ch.h" +#include "vauno_en8822c.h" #include "pocsag.h" #include "schrader_gg4.h" #include "bin_raw.h" diff --git a/lib/subghz/protocols/vauno_en8822c.c b/lib/subghz/protocols/vauno_en8822c.c new file mode 100644 index 000000000..e80ec2f84 --- /dev/null +++ b/lib/subghz/protocols/vauno_en8822c.c @@ -0,0 +1,258 @@ +#include "vauno_en8822c.h" +#include "furi/core/log.h" +#define TAG "WSProtocolVaunoEN8822C" + +/* + * Help + * https://github.com/merbanan/rtl_433/blob/master/src/devices/vauno_en8822c.c + * + * Vauno EN8822C sensor on 433.92MHz. + * + * Largely the same as Esperanza EWS, s3318p. + * @sa esperanza_ews.c s3318p.c + + * List of known supported devices: + * - Vauno EN8822C-1 + * - FUZHOU ESUN ELECTRONIC outdoor T21 sensor + * + * Frame structure (42 bits): + * + * Byte: 0 1 2 3 4 + * Nibble: 1 2 3 4 5 6 7 8 9 10 11 + * Type: IIIIIIII B?CCTTTT TTTTTTTT HHHHHHHF FFFBXXXX XX + * + * - I: Random device ID + * - C: Channel (1-3) + * - T: Temperature (Little-endian) + * - H: Humidity (Little-endian) + * - F: Flags (unknown) + * - B: Battery (1=low voltage ~<2.5V) + * - X: Checksum (6 bit nibble sum) + * + * Sample Data: + * + * [00] {42} af 0f a2 7c 01 c0 : 10101111 00001111 10100010 01111100 00000001 11 + * + * - Sensor ID = 175 = 0xaf + * - Channel = 0 + * - temp = -93 = 0x111110100010 + * - TemperatureC = -9.3 + * - hum = 62% = 0x0111110 + * + * Copyright (C) 2022 Jamie Barron + * + * @m7i-org - because the ether is wavy + * + */ + +static const SubGhzBlockConst ws_protocol_vauno_en8822c_const = { + .te_short = 500, + .te_long = 1940, + .te_delta = 150, + .min_count_bit_for_found = 42, +}; + +struct WSProtocolDecoderVaunoEN8822C { + SubGhzProtocolDecoderBase base; + + SubGhzBlockDecoder decoder; + WSBlockGeneric generic; +}; + +struct WSProtocolEncoderVaunoEN8822C { + SubGhzProtocolEncoderBase base; + + SubGhzProtocolBlockEncoder encoder; + WSBlockGeneric generic; +}; + +const SubGhzProtocolDecoder ws_protocol_vauno_en8822c_decoder = { + .alloc = ws_protocol_decoder_vauno_en8822c_alloc, + .free = ws_protocol_decoder_vauno_en8822c_free, + + .feed = ws_protocol_decoder_vauno_en8822c_feed, + .reset = ws_protocol_decoder_vauno_en8822c_reset, + + .get_hash_data = NULL, + .get_hash_data_long = ws_protocol_decoder_vauno_en8822c_get_hash_data, + .serialize = ws_protocol_decoder_vauno_en8822c_serialize, + .deserialize = ws_protocol_decoder_vauno_en8822c_deserialize, + .get_string = ws_protocol_decoder_vauno_en8822c_get_string, + .get_string_brief = NULL, +}; + +const SubGhzProtocolEncoder ws_protocol_vauno_en8822c_encoder = { + .alloc = NULL, + .free = NULL, + + .deserialize = NULL, + .stop = NULL, + .yield = NULL, +}; + +const SubGhzProtocol ws_protocol_vauno_en8822c = { + .name = WS_PROTOCOL_VAUNO_EN8822C_NAME, + .type = SubGhzProtocolTypeStatic, + .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_868 | + SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | + SubGhzProtocolFlag_Save, + .filter = SubGhzProtocolFilter_Weather, + .decoder = &ws_protocol_vauno_en8822c_decoder, + .encoder = &ws_protocol_vauno_en8822c_encoder, +}; + +typedef enum { + VaunoEN8822CDecoderStepReset = 0, + VaunoEN8822CDecoderStepSaveDuration, + VaunoEN8822CDecoderStepCheckDuration, +} VaunoEN8822CDecoderStep; + +void* ws_protocol_decoder_vauno_en8822c_alloc(SubGhzEnvironment* environment) { + UNUSED(environment); + WSProtocolDecoderVaunoEN8822C* instance = malloc(sizeof(WSProtocolDecoderVaunoEN8822C)); + instance->base.protocol = &ws_protocol_vauno_en8822c; + instance->generic.protocol_name = instance->base.protocol->name; + return instance; +} + +void ws_protocol_decoder_vauno_en8822c_free(void* context) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + free(instance); +} + +void ws_protocol_decoder_vauno_en8822c_reset(void* context) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + instance->decoder.parser_step = VaunoEN8822CDecoderStepReset; +} + +static bool ws_protocol_vauno_en8822c_check(WSProtocolDecoderVaunoEN8822C* instance) { + if(!instance->decoder.decode_data) return false; + + // The sum of all nibbles should match the last 6 bits + uint8_t sum = 0; + for(uint8_t i = 6; i <= 38; i += 4) { + sum += ((instance->decoder.decode_data >> i) & 0x0f); + } + + return sum != 0 && (sum & 0x3f) == (instance->decoder.decode_data & 0x3f); +} + +/** + * Analysis of received data + * @param instance Pointer to a WSBlockGeneric* instance + */ +static void ws_protocol_vauno_en8822c_extract_data(WSBlockGeneric* instance) { + instance->id = (instance->data >> 34) & 0xff; + instance->battery_low = (instance->data >> 33) & 0x01; + instance->channel = ((instance->data >> 30) & 0x03); + + int16_t temp = (instance->data >> 18) & 0x0fff; + /* Handle signed data */ + if(temp & 0x0800) { + temp |= 0xf000; + } + instance->temp = (float)temp / 10.0; + + instance->humidity = (instance->data >> 11) & 0x7f; + instance->btn = WS_NO_BTN; +} + +void ws_protocol_decoder_vauno_en8822c_feed(void* context, bool level, uint32_t duration) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + + switch(instance->decoder.parser_step) { + case VaunoEN8822CDecoderStepReset: + if((!level) && DURATION_DIFF(duration, ws_protocol_vauno_en8822c_const.te_long * 4) < + ws_protocol_vauno_en8822c_const.te_delta) { + instance->decoder.parser_step = VaunoEN8822CDecoderStepSaveDuration; + instance->decoder.decode_data = 0; + instance->decoder.decode_count_bit = 0; + } + break; + + case VaunoEN8822CDecoderStepSaveDuration: + if(level) { + instance->decoder.te_last = duration; + instance->decoder.parser_step = VaunoEN8822CDecoderStepCheckDuration; + } else { + instance->decoder.parser_step = VaunoEN8822CDecoderStepReset; + } + break; + + case VaunoEN8822CDecoderStepCheckDuration: + if(!level) { + if(DURATION_DIFF(instance->decoder.te_last, ws_protocol_vauno_en8822c_const.te_short) < + ws_protocol_vauno_en8822c_const.te_delta) { + if(DURATION_DIFF(duration, ws_protocol_vauno_en8822c_const.te_long * 2) < + ws_protocol_vauno_en8822c_const.te_delta) { + subghz_protocol_blocks_add_bit(&instance->decoder, 1); + instance->decoder.parser_step = VaunoEN8822CDecoderStepSaveDuration; + } else if( + DURATION_DIFF(duration, ws_protocol_vauno_en8822c_const.te_long) < + ws_protocol_vauno_en8822c_const.te_delta) { + subghz_protocol_blocks_add_bit(&instance->decoder, 0); + instance->decoder.parser_step = VaunoEN8822CDecoderStepSaveDuration; + } else if( + DURATION_DIFF(duration, ws_protocol_vauno_en8822c_const.te_long * 4) < + ws_protocol_vauno_en8822c_const.te_delta) { + instance->decoder.parser_step = VaunoEN8822CDecoderStepReset; + if(instance->decoder.decode_count_bit == + ws_protocol_vauno_en8822c_const.min_count_bit_for_found && + ws_protocol_vauno_en8822c_check(instance)) { + instance->generic.data = instance->decoder.decode_data; + instance->generic.data_count_bit = instance->decoder.decode_count_bit; + ws_protocol_vauno_en8822c_extract_data(&instance->generic); + + if(instance->base.callback) { + instance->base.callback(&instance->base, instance->base.context); + } + } else if(instance->decoder.decode_count_bit == 1) { + instance->decoder.parser_step = VaunoEN8822CDecoderStepSaveDuration; + } + + instance->decoder.decode_data = 0; + instance->decoder.decode_count_bit = 0; + } else + instance->decoder.parser_step = VaunoEN8822CDecoderStepReset; + } else + instance->decoder.parser_step = VaunoEN8822CDecoderStepReset; + } else + instance->decoder.parser_step = VaunoEN8822CDecoderStepReset; + break; + } +} + +uint32_t ws_protocol_decoder_vauno_en8822c_get_hash_data(void* context) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + return subghz_protocol_blocks_get_hash_data_long( + &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1); +} + +SubGhzProtocolStatus ws_protocol_decoder_vauno_en8822c_serialize( + void* context, + FlipperFormat* flipper_format, + SubGhzRadioPreset* preset) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + return ws_block_generic_serialize(&instance->generic, flipper_format, preset); +} + +SubGhzProtocolStatus + ws_protocol_decoder_vauno_en8822c_deserialize(void* context, FlipperFormat* flipper_format) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + return ws_block_generic_deserialize_check_count_bit( + &instance->generic, + flipper_format, + ws_protocol_vauno_en8822c_const.min_count_bit_for_found); +} + +void ws_protocol_decoder_vauno_en8822c_get_string(void* context, FuriString* output) { + furi_assert(context); + WSProtocolDecoderVaunoEN8822C* instance = context; + ws_block_generic_get_string(&instance->generic, output); +} diff --git a/lib/subghz/protocols/vauno_en8822c.h b/lib/subghz/protocols/vauno_en8822c.h new file mode 100644 index 000000000..5c61d32d6 --- /dev/null +++ b/lib/subghz/protocols/vauno_en8822c.h @@ -0,0 +1,80 @@ +#pragma once + +#include + +#include +#include +#include +#include "ws_generic.h" +#include + +#define WS_PROTOCOL_VAUNO_EN8822C_NAME "Vauno-EN8822C" + +typedef struct WSProtocolDecoderVaunoEN8822C WSProtocolDecoderVaunoEN8822C; +typedef struct WSProtocolEncoderVaunoEN8822C WSProtocolEncoderVaunoEN8822C; + +extern const SubGhzProtocolDecoder ws_protocol_vauno_en8822c_decoder; +extern const SubGhzProtocolEncoder ws_protocol_vauno_en8822c_encoder; +extern const SubGhzProtocol ws_protocol_vauno_en8822c; + +/** + * Allocate WSProtocolDecoderVaunoEN8822C. + * @param environment Pointer to a SubGhzEnvironment instance + * @return WSProtocolDecoderVaunoEN8822C* pointer to a WSProtocolDecoderVaunoEN8822C instance + */ +void* ws_protocol_decoder_vauno_en8822c_alloc(SubGhzEnvironment* environment); + +/** + * Free WSProtocolDecoderVaunoEN8822C. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + */ +void ws_protocol_decoder_vauno_en8822c_free(void* context); + +/** + * Reset decoder WSProtocolDecoderVaunoEN8822C. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + */ +void ws_protocol_decoder_vauno_en8822c_reset(void* context); + +/** + * Parse a raw sequence of levels and durations received from the air. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + * @param level Signal level true-high false-low + * @param duration Duration of this level in, us + */ +void ws_protocol_decoder_vauno_en8822c_feed(void* context, bool level, uint32_t duration); + +/** + * Getting the hash sum of the last randomly received parcel. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + * @return hash Hash sum + */ +uint32_t ws_protocol_decoder_vauno_en8822c_get_hash_data(void* context); + +/** + * Serialize data WSProtocolDecoderVaunoEN8822C. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + * @param flipper_format Pointer to a FlipperFormat instance + * @param preset The modulation on which the signal was received, SubGhzRadioPreset + * @return status + */ +SubGhzProtocolStatus ws_protocol_decoder_vauno_en8822c_serialize( + void* context, + FlipperFormat* flipper_format, + SubGhzRadioPreset* preset); + +/** + * Deserialize data WSProtocolDecoderVaunoEN8822C. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + * @param flipper_format Pointer to a FlipperFormat instance + * @return status + */ +SubGhzProtocolStatus + ws_protocol_decoder_vauno_en8822c_deserialize(void* context, FlipperFormat* flipper_format); + +/** + * Getting a textual representation of the received data. + * @param context Pointer to a WSProtocolDecoderVaunoEN8822C instance + * @param output Resulting text + */ +void ws_protocol_decoder_vauno_en8822c_get_string(void* context, FuriString* output); diff --git a/scripts/asset_packer.py b/scripts/asset_packer.py index dcfa68f8e..dda625fc3 100755 --- a/scripts/asset_packer.py +++ b/scripts/asset_packer.py @@ -45,6 +45,10 @@ def convert_bmx(img: "Image.Image | pathlib.Path") -> bytes: return data +def copy_file_as_lf(src: "pathlib.Path", dst: "pathlib.Path"): + dst.write_bytes(src.read_bytes().replace(b"\r\n", b"\n")) + + def pack_anim(src: pathlib.Path, dst: pathlib.Path): if not (src / "meta.txt").is_file(): return @@ -53,7 +57,7 @@ def pack_anim(src: pathlib.Path, dst: pathlib.Path): if not frame.is_file(): continue if frame.name == "meta.txt": - shutil.copyfile(frame, dst / frame.name) + copy_file_as_lf(frame, dst / frame.name) elif frame.name.startswith("frame_"): if frame.suffix == ".png": (dst / frame.with_suffix(".bm").name).write_bytes(convert_bm(frame)) @@ -145,7 +149,7 @@ def pack( if (source / "Anims/manifest.txt").exists(): (packed / "Anims").mkdir(parents=True, exist_ok=True) - shutil.copyfile( + copy_file_as_lf( source / "Anims/manifest.txt", packed / "Anims/manifest.txt" ) manifest = (source / "Anims/manifest.txt").read_bytes() diff --git a/scripts/fbt_tools/fbt_extapps.py b/scripts/fbt_tools/fbt_extapps.py index 9c3c28124..da5e272a8 100644 --- a/scripts/fbt_tools/fbt_extapps.py +++ b/scripts/fbt_tools/fbt_extapps.py @@ -314,8 +314,9 @@ def _validate_app_imports(target, source, env): "totp_", "token_info_", "memset_s", - # troika + # social_moscow, troika "mosgortrans_parse_transport_block", + "render_section_header", ) ) and any( @@ -324,6 +325,7 @@ def _validate_app_imports(target, source, env): "advanced_plugin", "gallagher", "js_", # js_app and all js_ modules + "social_moscow", "test_js", "totp_", "troika", diff --git a/scripts/fix_ir_universals.py b/scripts/fix_ir_universals.py new file mode 100755 index 000000000..e51687593 --- /dev/null +++ b/scripts/fix_ir_universals.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python3 +import pathlib + +universals = ( + pathlib.Path(__file__).parent + / "../applications/main/infrared/resources/infrared/assets" +) + +for universal in universals.glob("*.ir"): + text = universal.read_text() + lines = text.splitlines() + signal = [] + comment = [] + signals = [] + for line in lines: + if line.startswith("#"): + comment.append(line) + continue + signal.append(line) + if line.startswith(("data: ", "command: ")): # Last line of this signal + signals.append(("\n".join(signal), "\n".join(comment))) + signal.clear() + comment.clear() + found = dict() + for signal, comment in signals: + if signal in found: + if ( + universal.stem == "projectors" + and found[signal] == 1 + and signal.startswith("name: Power") + ): + # Projectors need double press of power to confirm shutdown, so 1 dupe is fine + found[signal] += 1 + continue + replace = f"\n{comment}\n{signal}" + pos = text.rfind(replace) + text = text[:pos] + text[pos + len(replace) :] + continue + found[signal] = 1 + universal.write_text(text) diff --git a/scripts/fix_mfc_dict.py b/scripts/fix_mfc_dict.py old mode 100644 new mode 100755 index 3bdaf5c69..f89973d3c --- a/scripts/fix_mfc_dict.py +++ b/scripts/fix_mfc_dict.py @@ -1,3 +1,4 @@ +#!/usr/bin/env python3 import pathlib import string diff --git a/targets/f7/api_symbols.csv b/targets/f7/api_symbols.csv index 9ceb0f14b..55c66b02d 100644 --- a/targets/f7/api_symbols.csv +++ b/targets/f7/api_symbols.csv @@ -975,7 +975,7 @@ Function,+,dir_walk_read,DirWalkResult,"DirWalk*, FuriString*, FileInfo*" Function,+,dir_walk_set_filter_cb,void,"DirWalk*, DirWalkFilterCb, void*" Function,+,dir_walk_set_recurse_filter,void,"DirWalk*, const char**, size_t" Function,+,dir_walk_set_recursive,void,"DirWalk*, _Bool" -Function,-,div,div_t,"int, int" +Function,+,div,div_t,"int, int" Function,+,dolphin_deed,void,DolphinDeed Function,+,dolphin_deed_get_app,DolphinApp,DolphinDeed Function,+,dolphin_deed_get_app_limit,uint8_t,DolphinApp @@ -2587,6 +2587,7 @@ Function,+,mf_classic_get_base_data,Iso14443_3aData*,const MfClassicData* Function,+,mf_classic_get_blocks_num_in_sector,uint8_t,uint8_t Function,+,mf_classic_get_device_name,const char*,"const MfClassicData*, NfcDeviceNameType" Function,+,mf_classic_get_first_block_num_of_sector,uint8_t,uint8_t +Function,+,mf_classic_get_key,MfClassicKey,"const MfClassicData*, uint8_t, MfClassicKeyType" Function,+,mf_classic_get_read_sectors_and_keys,void,"const MfClassicData*, uint8_t*, uint8_t*" Function,+,mf_classic_get_sector_by_block,uint8_t,uint8_t Function,+,mf_classic_get_sector_trailer_by_sector,MfClassicSectorTrailer*,"const MfClassicData*, uint8_t" @@ -3668,8 +3669,6 @@ Function,+,text_box_reset,void,TextBox* Function,+,text_box_set_focus,void,"TextBox*, TextBoxFocus" Function,+,text_box_set_font,void,"TextBox*, TextBoxFont" Function,+,text_box_set_text,void,"TextBox*, const char*" -Function,+,text_input_add_extra_symbol,void,"TextInput*, char" -Function,+,text_input_add_illegal_symbols,void,TextInput* Function,+,text_input_alloc,TextInput*, Function,+,text_input_free,void,TextInput* Function,+,text_input_get_validator_callback,TextInputValidatorCallback,TextInput* @@ -3680,6 +3679,7 @@ Function,+,text_input_set_header_text,void,"TextInput*, const char*" Function,+,text_input_set_minimum_length,void,"TextInput*, size_t" Function,+,text_input_set_result_callback,void,"TextInput*, TextInputCallback, void*, char*, size_t, _Bool" Function,+,text_input_set_validator,void,"TextInput*, TextInputValidatorCallback, void*" +Function,+,text_input_show_illegal_symbols,void,"TextInput*, _Bool" Function,-,tgamma,double,double Function,-,tgammaf,float,float Function,-,tgammal,long double,long double