From 12004d0ef49a05cf484d49795265eaf619c19580 Mon Sep 17 00:00:00 2001 From: Willy-JL <49810075+Willy-JL@users.noreply.github.com> Date: Fri, 11 Aug 2023 22:54:16 +0200 Subject: [PATCH] Format --- .../external/esubghz_chat/crypto/aes.c | 507 +++++---- .../external/esubghz_chat/crypto/aes.h | 49 +- .../external/esubghz_chat/crypto/gcm.c | 387 +++---- .../external/esubghz_chat/crypto/gcm.h | 126 ++- .../external/esubghz_chat/crypto_wrapper.c | 258 ++--- .../external/esubghz_chat/crypto_wrapper.h | 23 +- .../external/esubghz_chat/esubghz_chat.c | 963 +++++++++--------- .../scenes/esubghz_chat_chat_box.c | 84 +- .../scenes/esubghz_chat_chat_input.c | 149 ++- .../scenes/esubghz_chat_freq_input.c | 160 ++- .../scenes/esubghz_chat_hex_key_input.c | 113 +- .../scenes/esubghz_chat_key_display.c | 209 ++-- .../scenes/esubghz_chat_key_menu.c | 268 +++-- .../scenes/esubghz_chat_key_read_popup.c | 360 +++---- .../scenes/esubghz_chat_key_share_popup.c | 108 +- .../scenes/esubghz_chat_pass_input.c | 158 ++- .../esubghz_chat/scenes/esubghz_chat_scene.h | 4 +- .../external/wire_tester/wire_tester.c | 21 +- 18 files changed, 1877 insertions(+), 2070 deletions(-) diff --git a/applications/external/esubghz_chat/crypto/aes.c b/applications/external/esubghz_chat/crypto/aes.c index 2be72d571..b2fe5fced 100644 --- a/applications/external/esubghz_chat/crypto/aes.c +++ b/applications/external/esubghz_chat/crypto/aes.c @@ -22,8 +22,8 @@ #include "aes.h" -static int aes_tables_inited = 0; // run-once flag for performing key - // expasion table generation (see below) +static int aes_tables_inited = 0; // run-once flag for performing key + // expasion table generation (see below) /* * The following static local tables must be filled-in before the first use of * the GCM or AES ciphers. They are used for the AES key expansion/scheduling @@ -37,99 +37,94 @@ static int aes_tables_inited = 0; // run-once flag for performing key * the GCM input, we ONLY NEED AES encryption. Thus, to save space AES * decryption is typically disabled by setting AES_DECRYPTION to 0 in aes.h. */ - // We always need our forward tables -static uchar FSb[256]; // Forward substitution box (FSb) -static uint32_t FT0[256]; // Forward key schedule assembly tables +// We always need our forward tables +static uchar FSb[256]; // Forward substitution box (FSb) +static uint32_t FT0[256]; // Forward key schedule assembly tables static uint32_t FT1[256]; static uint32_t FT2[256]; static uint32_t FT3[256]; -#if AES_DECRYPTION // We ONLY need reverse for decryption -static uchar RSb[256]; // Reverse substitution box (RSb) -static uint32_t RT0[256]; // Reverse key schedule assembly tables +#if AES_DECRYPTION // We ONLY need reverse for decryption +static uchar RSb[256]; // Reverse substitution box (RSb) +static uint32_t RT0[256]; // Reverse key schedule assembly tables static uint32_t RT1[256]; static uint32_t RT2[256]; static uint32_t RT3[256]; -#endif /* AES_DECRYPTION */ +#endif /* AES_DECRYPTION */ -static uint32_t RCON[10]; // AES round constants +static uint32_t RCON[10]; // AES round constants /* * Platform Endianness Neutralizing Load and Store Macro definitions * AES wants platform-neutral Little Endian (LE) byte ordering */ -#define GET_UINT32_LE(n,b,i) { \ - (n) = ( (uint32_t) (b)[(i) ] ) \ - | ( (uint32_t) (b)[(i) + 1] << 8 ) \ - | ( (uint32_t) (b)[(i) + 2] << 16 ) \ - | ( (uint32_t) (b)[(i) + 3] << 24 ); } +#define GET_UINT32_LE(n, b, i) \ + { \ + (n) = ((uint32_t)(b)[(i)]) | ((uint32_t)(b)[(i) + 1] << 8) | \ + ((uint32_t)(b)[(i) + 2] << 16) | ((uint32_t)(b)[(i) + 3] << 24); \ + } -#define PUT_UINT32_LE(n,b,i) { \ - (b)[(i) ] = (uchar) ( (n) ); \ - (b)[(i) + 1] = (uchar) ( (n) >> 8 ); \ - (b)[(i) + 2] = (uchar) ( (n) >> 16 ); \ - (b)[(i) + 3] = (uchar) ( (n) >> 24 ); } +#define PUT_UINT32_LE(n, b, i) \ + { \ + (b)[(i)] = (uchar)((n)); \ + (b)[(i) + 1] = (uchar)((n) >> 8); \ + (b)[(i) + 2] = (uchar)((n) >> 16); \ + (b)[(i) + 3] = (uchar)((n) >> 24); \ + } /* * AES forward and reverse encryption round processing macros */ -#define AES_FROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \ -{ \ - X0 = *RK++ ^ FT0[ ( Y0 ) & 0xFF ] ^ \ - FT1[ ( Y1 >> 8 ) & 0xFF ] ^ \ - FT2[ ( Y2 >> 16 ) & 0xFF ] ^ \ - FT3[ ( Y3 >> 24 ) & 0xFF ]; \ - \ - X1 = *RK++ ^ FT0[ ( Y1 ) & 0xFF ] ^ \ - FT1[ ( Y2 >> 8 ) & 0xFF ] ^ \ - FT2[ ( Y3 >> 16 ) & 0xFF ] ^ \ - FT3[ ( Y0 >> 24 ) & 0xFF ]; \ - \ - X2 = *RK++ ^ FT0[ ( Y2 ) & 0xFF ] ^ \ - FT1[ ( Y3 >> 8 ) & 0xFF ] ^ \ - FT2[ ( Y0 >> 16 ) & 0xFF ] ^ \ - FT3[ ( Y1 >> 24 ) & 0xFF ]; \ - \ - X3 = *RK++ ^ FT0[ ( Y3 ) & 0xFF ] ^ \ - FT1[ ( Y0 >> 8 ) & 0xFF ] ^ \ - FT2[ ( Y1 >> 16 ) & 0xFF ] ^ \ - FT3[ ( Y2 >> 24 ) & 0xFF ]; \ -} +#define AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3) \ + { \ + X0 = *RK++ ^ FT0[(Y0)&0xFF] ^ FT1[(Y1 >> 8) & 0xFF] ^ FT2[(Y2 >> 16) & 0xFF] ^ \ + FT3[(Y3 >> 24) & 0xFF]; \ + \ + X1 = *RK++ ^ FT0[(Y1)&0xFF] ^ FT1[(Y2 >> 8) & 0xFF] ^ FT2[(Y3 >> 16) & 0xFF] ^ \ + FT3[(Y0 >> 24) & 0xFF]; \ + \ + X2 = *RK++ ^ FT0[(Y2)&0xFF] ^ FT1[(Y3 >> 8) & 0xFF] ^ FT2[(Y0 >> 16) & 0xFF] ^ \ + FT3[(Y1 >> 24) & 0xFF]; \ + \ + X3 = *RK++ ^ FT0[(Y3)&0xFF] ^ FT1[(Y0 >> 8) & 0xFF] ^ FT2[(Y1 >> 16) & 0xFF] ^ \ + FT3[(Y2 >> 24) & 0xFF]; \ + } -#define AES_RROUND(X0,X1,X2,X3,Y0,Y1,Y2,Y3) \ -{ \ - X0 = *RK++ ^ RT0[ ( Y0 ) & 0xFF ] ^ \ - RT1[ ( Y3 >> 8 ) & 0xFF ] ^ \ - RT2[ ( Y2 >> 16 ) & 0xFF ] ^ \ - RT3[ ( Y1 >> 24 ) & 0xFF ]; \ - \ - X1 = *RK++ ^ RT0[ ( Y1 ) & 0xFF ] ^ \ - RT1[ ( Y0 >> 8 ) & 0xFF ] ^ \ - RT2[ ( Y3 >> 16 ) & 0xFF ] ^ \ - RT3[ ( Y2 >> 24 ) & 0xFF ]; \ - \ - X2 = *RK++ ^ RT0[ ( Y2 ) & 0xFF ] ^ \ - RT1[ ( Y1 >> 8 ) & 0xFF ] ^ \ - RT2[ ( Y0 >> 16 ) & 0xFF ] ^ \ - RT3[ ( Y3 >> 24 ) & 0xFF ]; \ - \ - X3 = *RK++ ^ RT0[ ( Y3 ) & 0xFF ] ^ \ - RT1[ ( Y2 >> 8 ) & 0xFF ] ^ \ - RT2[ ( Y1 >> 16 ) & 0xFF ] ^ \ - RT3[ ( Y0 >> 24 ) & 0xFF ]; \ -} +#define AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3) \ + { \ + X0 = *RK++ ^ RT0[(Y0)&0xFF] ^ RT1[(Y3 >> 8) & 0xFF] ^ RT2[(Y2 >> 16) & 0xFF] ^ \ + RT3[(Y1 >> 24) & 0xFF]; \ + \ + X1 = *RK++ ^ RT0[(Y1)&0xFF] ^ RT1[(Y0 >> 8) & 0xFF] ^ RT2[(Y3 >> 16) & 0xFF] ^ \ + RT3[(Y2 >> 24) & 0xFF]; \ + \ + X2 = *RK++ ^ RT0[(Y2)&0xFF] ^ RT1[(Y1 >> 8) & 0xFF] ^ RT2[(Y0 >> 16) & 0xFF] ^ \ + RT3[(Y3 >> 24) & 0xFF]; \ + \ + X3 = *RK++ ^ RT0[(Y3)&0xFF] ^ RT1[(Y2 >> 8) & 0xFF] ^ RT2[(Y1 >> 16) & 0xFF] ^ \ + RT3[(Y0 >> 24) & 0xFF]; \ + } /* * These macros improve the readability of the key * generation initialization code by collapsing * repetitive common operations into logical pieces. */ -#define ROTL8(x) ( ( x << 8 ) & 0xFFFFFFFF ) | ( x >> 24 ) -#define XTIME(x) ( ( x << 1 ) ^ ( ( x & 0x80 ) ? 0x1B : 0x00 ) ) -#define MUL(x,y) ( ( x && y ) ? pow[(log[x]+log[y]) % 255] : 0 ) -#define MIX(x,y) { y = ( (y << 1) | (y >> 7) ) & 0xFF; x ^= y; } -#define CPY128 { *RK++ = *SK++; *RK++ = *SK++; \ - *RK++ = *SK++; *RK++ = *SK++; } +#define ROTL8(x) ((x << 8) & 0xFFFFFFFF) | (x >> 24) +#define XTIME(x) ((x << 1) ^ ((x & 0x80) ? 0x1B : 0x00)) +#define MUL(x, y) ((x && y) ? pow[(log[x] + log[y]) % 255] : 0) +#define MIX(x, y) \ + { \ + y = ((y << 1) | (y >> 7)) & 0xFF; \ + x ^= y; \ + } +#define CPY128 \ + { \ + *RK++ = *SK++; \ + *RK++ = *SK++; \ + *RK++ = *SK++; \ + *RK++ = *SK++; \ + } /****************************************************************************** * @@ -141,71 +136,66 @@ static uint32_t RCON[10]; // AES round constants * at system initialization to setup the tables for all subsequent use. * ******************************************************************************/ -void aes_init_keygen_tables( void ) -{ - int i, x, y, z; // general purpose iteration and computation locals +void aes_init_keygen_tables(void) { + int i, x, y, z; // general purpose iteration and computation locals int pow[256]; int log[256]; - if (aes_tables_inited) return; + if(aes_tables_inited) return; // fill the 'pow' and 'log' tables over GF(2^8) - for( i = 0, x = 1; i < 256; i++ ) { + for(i = 0, x = 1; i < 256; i++) { pow[i] = x; log[x] = i; - x = ( x ^ XTIME( x ) ) & 0xFF; + x = (x ^ XTIME(x)) & 0xFF; } // compute the round constants - for( i = 0, x = 1; i < 10; i++ ) { - RCON[i] = (uint32_t) x; - x = XTIME( x ) & 0xFF; + for(i = 0, x = 1; i < 10; i++) { + RCON[i] = (uint32_t)x; + x = XTIME(x) & 0xFF; } // fill the forward and reverse substitution boxes FSb[0x00] = 0x63; -#if AES_DECRYPTION // whether AES decryption is supported +#if AES_DECRYPTION // whether AES decryption is supported RSb[0x63] = 0x00; #endif /* AES_DECRYPTION */ - for( i = 1; i < 256; i++ ) { + for(i = 1; i < 256; i++) { x = y = pow[255 - log[i]]; - MIX(x,y); - MIX(x,y); - MIX(x,y); - MIX(x,y); - FSb[i] = (uchar) ( x ^= 0x63 ); -#if AES_DECRYPTION // whether AES decryption is supported - RSb[x] = (uchar) i; + MIX(x, y); + MIX(x, y); + MIX(x, y); + MIX(x, y); + FSb[i] = (uchar)(x ^= 0x63); +#if AES_DECRYPTION // whether AES decryption is supported + RSb[x] = (uchar)i; #endif /* AES_DECRYPTION */ - } // generate the forward and reverse key expansion tables - for( i = 0; i < 256; i++ ) { + for(i = 0; i < 256; i++) { x = FSb[i]; - y = XTIME( x ) & 0xFF; - z = ( y ^ x ) & 0xFF; + y = XTIME(x) & 0xFF; + z = (y ^ x) & 0xFF; - FT0[i] = ( (uint32_t) y ) ^ ( (uint32_t) x << 8 ) ^ - ( (uint32_t) x << 16 ) ^ ( (uint32_t) z << 24 ); + FT0[i] = ((uint32_t)y) ^ ((uint32_t)x << 8) ^ ((uint32_t)x << 16) ^ ((uint32_t)z << 24); - FT1[i] = ROTL8( FT0[i] ); - FT2[i] = ROTL8( FT1[i] ); - FT3[i] = ROTL8( FT2[i] ); + FT1[i] = ROTL8(FT0[i]); + FT2[i] = ROTL8(FT1[i]); + FT3[i] = ROTL8(FT2[i]); -#if AES_DECRYPTION // whether AES decryption is supported +#if AES_DECRYPTION // whether AES decryption is supported x = RSb[i]; - RT0[i] = ( (uint32_t) MUL( 0x0E, x ) ) ^ - ( (uint32_t) MUL( 0x09, x ) << 8 ) ^ - ( (uint32_t) MUL( 0x0D, x ) << 16 ) ^ - ( (uint32_t) MUL( 0x0B, x ) << 24 ); + RT0[i] = ((uint32_t)MUL(0x0E, x)) ^ ((uint32_t)MUL(0x09, x) << 8) ^ + ((uint32_t)MUL(0x0D, x) << 16) ^ ((uint32_t)MUL(0x0B, x) << 24); - RT1[i] = ROTL8( RT0[i] ); - RT2[i] = ROTL8( RT1[i] ); - RT3[i] = ROTL8( RT2[i] ); + RT1[i] = ROTL8(RT0[i]); + RT2[i] = ROTL8(RT1[i]); + RT3[i] = ROTL8(RT2[i]); #endif /* AES_DECRYPTION */ } - aes_tables_inited = 1; // flag that the tables have been generated -} // to permit subsequent use of the AES cipher + aes_tables_inited = 1; // flag that the tables have been generated +} // to permit subsequent use of the AES cipher /****************************************************************************** * @@ -217,80 +207,72 @@ void aes_init_keygen_tables( void ) * Valid lengths are: 16, 24 or 32 bytes (128, 192, 256 bits). * ******************************************************************************/ -int aes_set_encryption_key( aes_context *ctx, - const uchar *key, - uint keysize ) -{ - uint i; // general purpose iteration local - uint32_t *RK = ctx->rk; // initialize our RoundKey buffer pointer +int aes_set_encryption_key(aes_context* ctx, const uchar* key, uint keysize) { + uint i; // general purpose iteration local + uint32_t* RK = ctx->rk; // initialize our RoundKey buffer pointer - for( i = 0; i < (keysize >> 2); i++ ) { - GET_UINT32_LE( RK[i], key, i << 2 ); + for(i = 0; i < (keysize >> 2); i++) { + GET_UINT32_LE(RK[i], key, i << 2); } - switch( ctx->rounds ) - { - case 10: - for( i = 0; i < 10; i++, RK += 4 ) { - RK[4] = RK[0] ^ RCON[i] ^ - ( (uint32_t) FSb[ ( RK[3] >> 8 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( RK[3] >> 16 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( RK[3] >> 24 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( RK[3] ) & 0xFF ] << 24 ); + switch(ctx->rounds) { + case 10: + for(i = 0; i < 10; i++, RK += 4) { + RK[4] = RK[0] ^ RCON[i] ^ ((uint32_t)FSb[(RK[3] >> 8) & 0xFF]) ^ + ((uint32_t)FSb[(RK[3] >> 16) & 0xFF] << 8) ^ + ((uint32_t)FSb[(RK[3] >> 24) & 0xFF] << 16) ^ + ((uint32_t)FSb[(RK[3]) & 0xFF] << 24); - RK[5] = RK[1] ^ RK[4]; - RK[6] = RK[2] ^ RK[5]; - RK[7] = RK[3] ^ RK[6]; - } - break; + RK[5] = RK[1] ^ RK[4]; + RK[6] = RK[2] ^ RK[5]; + RK[7] = RK[3] ^ RK[6]; + } + break; - case 12: - for( i = 0; i < 8; i++, RK += 6 ) { - RK[6] = RK[0] ^ RCON[i] ^ - ( (uint32_t) FSb[ ( RK[5] >> 8 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( RK[5] >> 16 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( RK[5] >> 24 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( RK[5] ) & 0xFF ] << 24 ); + case 12: + for(i = 0; i < 8; i++, RK += 6) { + RK[6] = RK[0] ^ RCON[i] ^ ((uint32_t)FSb[(RK[5] >> 8) & 0xFF]) ^ + ((uint32_t)FSb[(RK[5] >> 16) & 0xFF] << 8) ^ + ((uint32_t)FSb[(RK[5] >> 24) & 0xFF] << 16) ^ + ((uint32_t)FSb[(RK[5]) & 0xFF] << 24); - RK[7] = RK[1] ^ RK[6]; - RK[8] = RK[2] ^ RK[7]; - RK[9] = RK[3] ^ RK[8]; - RK[10] = RK[4] ^ RK[9]; - RK[11] = RK[5] ^ RK[10]; - } - break; + RK[7] = RK[1] ^ RK[6]; + RK[8] = RK[2] ^ RK[7]; + RK[9] = RK[3] ^ RK[8]; + RK[10] = RK[4] ^ RK[9]; + RK[11] = RK[5] ^ RK[10]; + } + break; - case 14: - for( i = 0; i < 7; i++, RK += 8 ) { - RK[8] = RK[0] ^ RCON[i] ^ - ( (uint32_t) FSb[ ( RK[7] >> 8 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( RK[7] >> 16 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( RK[7] >> 24 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( RK[7] ) & 0xFF ] << 24 ); + case 14: + for(i = 0; i < 7; i++, RK += 8) { + RK[8] = RK[0] ^ RCON[i] ^ ((uint32_t)FSb[(RK[7] >> 8) & 0xFF]) ^ + ((uint32_t)FSb[(RK[7] >> 16) & 0xFF] << 8) ^ + ((uint32_t)FSb[(RK[7] >> 24) & 0xFF] << 16) ^ + ((uint32_t)FSb[(RK[7]) & 0xFF] << 24); - RK[9] = RK[1] ^ RK[8]; - RK[10] = RK[2] ^ RK[9]; - RK[11] = RK[3] ^ RK[10]; + RK[9] = RK[1] ^ RK[8]; + RK[10] = RK[2] ^ RK[9]; + RK[11] = RK[3] ^ RK[10]; - RK[12] = RK[4] ^ - ( (uint32_t) FSb[ ( RK[11] ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( RK[11] >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( RK[11] >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( RK[11] >> 24 ) & 0xFF ] << 24 ); + RK[12] = RK[4] ^ ((uint32_t)FSb[(RK[11]) & 0xFF]) ^ + ((uint32_t)FSb[(RK[11] >> 8) & 0xFF] << 8) ^ + ((uint32_t)FSb[(RK[11] >> 16) & 0xFF] << 16) ^ + ((uint32_t)FSb[(RK[11] >> 24) & 0xFF] << 24); - RK[13] = RK[5] ^ RK[12]; - RK[14] = RK[6] ^ RK[13]; - RK[15] = RK[7] ^ RK[14]; - } - break; + RK[13] = RK[5] ^ RK[12]; + RK[14] = RK[6] ^ RK[13]; + RK[15] = RK[7] ^ RK[14]; + } + break; - default: - return -1; + default: + return -1; } - return( 0 ); + return (0); } -#if AES_DECRYPTION // whether AES decryption is supported +#if AES_DECRYPTION // whether AES decryption is supported /****************************************************************************** * @@ -302,37 +284,31 @@ int aes_set_encryption_key( aes_context *ctx, * length in bits. Valid lengths are: 128, 192, or 256 bits. * ******************************************************************************/ -int aes_set_decryption_key( aes_context *ctx, - const uchar *key, - uint keysize ) -{ +int aes_set_decryption_key(aes_context* ctx, const uchar* key, uint keysize) { int i, j; - aes_context cty; // a calling aes context for set_encryption_key - uint32_t *RK = ctx->rk; // initialize our RoundKey buffer pointer - uint32_t *SK; + aes_context cty; // a calling aes context for set_encryption_key + uint32_t* RK = ctx->rk; // initialize our RoundKey buffer pointer + uint32_t* SK; int ret; - cty.rounds = ctx->rounds; // initialize our local aes context - cty.rk = cty.buf; // round count and key buf pointer + cty.rounds = ctx->rounds; // initialize our local aes context + cty.rk = cty.buf; // round count and key buf pointer - if (( ret = aes_set_encryption_key( &cty, key, keysize )) != 0 ) - return( ret ); + if((ret = aes_set_encryption_key(&cty, key, keysize)) != 0) return (ret); SK = cty.rk + cty.rounds * 4; - CPY128 // copy a 128-bit block from *SK to *RK + CPY128 // copy a 128-bit block from *SK to *RK - for( i = ctx->rounds - 1, SK -= 8; i > 0; i--, SK -= 8 ) { - for( j = 0; j < 4; j++, SK++ ) { - *RK++ = RT0[ FSb[ ( *SK ) & 0xFF ] ] ^ - RT1[ FSb[ ( *SK >> 8 ) & 0xFF ] ] ^ - RT2[ FSb[ ( *SK >> 16 ) & 0xFF ] ] ^ - RT3[ FSb[ ( *SK >> 24 ) & 0xFF ] ]; + for(i = ctx->rounds - 1, SK -= 8; i > 0; i--, SK -= 8) { + for(j = 0; j < 4; j++, SK++) { + *RK++ = RT0[FSb[(*SK) & 0xFF]] ^ RT1[FSb[(*SK >> 8) & 0xFF]] ^ + RT2[FSb[(*SK >> 16) & 0xFF]] ^ RT3[FSb[(*SK >> 24) & 0xFF]]; } } - CPY128 // copy a 128-bit block from *SK to *RK - memset( &cty, 0, sizeof( aes_context ) ); // clear local aes context - return( 0 ); + CPY128 // copy a 128-bit block from *SK to *RK + memset(&cty, 0, sizeof(aes_context)); // clear local aes context + return (0); } #endif /* AES_DECRYPTION */ @@ -344,34 +320,42 @@ int aes_set_decryption_key( aes_context *ctx, * Invoked to establish the key schedule for subsequent encryption/decryption * ******************************************************************************/ -int aes_setkey( aes_context *ctx, // AES context provided by our caller - int mode, // ENCRYPT or DECRYPT flag - const uchar *key, // pointer to the key - uint keysize ) // key length in bytes +int aes_setkey( + aes_context* ctx, // AES context provided by our caller + int mode, // ENCRYPT or DECRYPT flag + const uchar* key, // pointer to the key + uint keysize) // key length in bytes { // since table initialization is not thread safe, we could either add // system-specific mutexes and init the AES key generation tables on // demand, or ask the developer to simply call "gcm_initialize" once during // application startup before threading begins. That's what we choose. - if( !aes_tables_inited ) return ( -1 ); // fail the call when not inited. - - ctx->mode = mode; // capture the key type we're creating - ctx->rk = ctx->buf; // initialize our round key pointer + if(!aes_tables_inited) return (-1); // fail the call when not inited. - switch( keysize ) // set the rounds count based upon the keysize + ctx->mode = mode; // capture the key type we're creating + ctx->rk = ctx->buf; // initialize our round key pointer + + switch(keysize) // set the rounds count based upon the keysize { - case 16: ctx->rounds = 10; break; // 16-byte, 128-bit key - case 24: ctx->rounds = 12; break; // 24-byte, 192-bit key - case 32: ctx->rounds = 14; break; // 32-byte, 256-bit key - default: return(-1); + case 16: + ctx->rounds = 10; + break; // 16-byte, 128-bit key + case 24: + ctx->rounds = 12; + break; // 24-byte, 192-bit key + case 32: + ctx->rounds = 14; + break; // 32-byte, 256-bit key + default: + return (-1); } #if AES_DECRYPTION - if( mode == DECRYPT ) // expand our key for encryption or decryption - return( aes_set_decryption_key( ctx, key, keysize ) ); - else /* ENCRYPT */ + if(mode == DECRYPT) // expand our key for encryption or decryption + return (aes_set_decryption_key(ctx, key, keysize)); + else /* ENCRYPT */ #endif /* AES_DECRYPTION */ - return( aes_set_encryption_key( ctx, key, keysize ) ); + return (aes_set_encryption_key(ctx, key, keysize)); } /****************************************************************************** @@ -383,101 +367,74 @@ int aes_setkey( aes_context *ctx, // AES context provided by our caller * and all keying information appropriate for the task. * ******************************************************************************/ -int aes_cipher( aes_context *ctx, - const uchar input[16], - uchar output[16] ) -{ +int aes_cipher(aes_context* ctx, const uchar input[16], uchar output[16]) { int i; - uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; // general purpose locals + uint32_t *RK, X0, X1, X2, X3, Y0, Y1, Y2, Y3; // general purpose locals RK = ctx->rk; - GET_UINT32_LE( X0, input, 0 ); X0 ^= *RK++; // load our 128-bit - GET_UINT32_LE( X1, input, 4 ); X1 ^= *RK++; // input buffer in a storage - GET_UINT32_LE( X2, input, 8 ); X2 ^= *RK++; // memory endian-neutral way - GET_UINT32_LE( X3, input, 12 ); X3 ^= *RK++; + GET_UINT32_LE(X0, input, 0); + X0 ^= *RK++; // load our 128-bit + GET_UINT32_LE(X1, input, 4); + X1 ^= *RK++; // input buffer in a storage + GET_UINT32_LE(X2, input, 8); + X2 ^= *RK++; // memory endian-neutral way + GET_UINT32_LE(X3, input, 12); + X3 ^= *RK++; -#if AES_DECRYPTION // whether AES decryption is supported +#if AES_DECRYPTION // whether AES decryption is supported - if( ctx->mode == DECRYPT ) - { - for( i = (ctx->rounds >> 1) - 1; i > 0; i-- ) - { - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); - AES_RROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); + if(ctx->mode == DECRYPT) { + for(i = (ctx->rounds >> 1) - 1; i > 0; i--) { + AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); + AES_RROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); } - AES_RROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); + AES_RROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); - X0 = *RK++ ^ \ - ( (uint32_t) RSb[ ( Y0 ) & 0xFF ] ) ^ - ( (uint32_t) RSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) RSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) RSb[ ( Y1 >> 24 ) & 0xFF ] << 24 ); + X0 = *RK++ ^ ((uint32_t)RSb[(Y0)&0xFF]) ^ ((uint32_t)RSb[(Y3 >> 8) & 0xFF] << 8) ^ + ((uint32_t)RSb[(Y2 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y1 >> 24) & 0xFF] << 24); - X1 = *RK++ ^ \ - ( (uint32_t) RSb[ ( Y1 ) & 0xFF ] ) ^ - ( (uint32_t) RSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) RSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) RSb[ ( Y2 >> 24 ) & 0xFF ] << 24 ); + X1 = *RK++ ^ ((uint32_t)RSb[(Y1)&0xFF]) ^ ((uint32_t)RSb[(Y0 >> 8) & 0xFF] << 8) ^ + ((uint32_t)RSb[(Y3 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y2 >> 24) & 0xFF] << 24); - X2 = *RK++ ^ \ - ( (uint32_t) RSb[ ( Y2 ) & 0xFF ] ) ^ - ( (uint32_t) RSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) RSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) RSb[ ( Y3 >> 24 ) & 0xFF ] << 24 ); + X2 = *RK++ ^ ((uint32_t)RSb[(Y2)&0xFF]) ^ ((uint32_t)RSb[(Y1 >> 8) & 0xFF] << 8) ^ + ((uint32_t)RSb[(Y0 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y3 >> 24) & 0xFF] << 24); - X3 = *RK++ ^ \ - ( (uint32_t) RSb[ ( Y3 ) & 0xFF ] ) ^ - ( (uint32_t) RSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) RSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) RSb[ ( Y0 >> 24 ) & 0xFF ] << 24 ); - } - else /* ENCRYPT */ + X3 = *RK++ ^ ((uint32_t)RSb[(Y3)&0xFF]) ^ ((uint32_t)RSb[(Y2 >> 8) & 0xFF] << 8) ^ + ((uint32_t)RSb[(Y1 >> 16) & 0xFF] << 16) ^ ((uint32_t)RSb[(Y0 >> 24) & 0xFF] << 24); + } else /* ENCRYPT */ { #endif /* AES_DECRYPTION */ - for( i = (ctx->rounds >> 1) - 1; i > 0; i-- ) - { - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); - AES_FROUND( X0, X1, X2, X3, Y0, Y1, Y2, Y3 ); + for(i = (ctx->rounds >> 1) - 1; i > 0; i--) { + AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); + AES_FROUND(X0, X1, X2, X3, Y0, Y1, Y2, Y3); } - AES_FROUND( Y0, Y1, Y2, Y3, X0, X1, X2, X3 ); + AES_FROUND(Y0, Y1, Y2, Y3, X0, X1, X2, X3); - X0 = *RK++ ^ \ - ( (uint32_t) FSb[ ( Y0 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( Y1 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( Y2 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( Y3 >> 24 ) & 0xFF ] << 24 ); + X0 = *RK++ ^ ((uint32_t)FSb[(Y0)&0xFF]) ^ ((uint32_t)FSb[(Y1 >> 8) & 0xFF] << 8) ^ + ((uint32_t)FSb[(Y2 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y3 >> 24) & 0xFF] << 24); - X1 = *RK++ ^ \ - ( (uint32_t) FSb[ ( Y1 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( Y2 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( Y3 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( Y0 >> 24 ) & 0xFF ] << 24 ); + X1 = *RK++ ^ ((uint32_t)FSb[(Y1)&0xFF]) ^ ((uint32_t)FSb[(Y2 >> 8) & 0xFF] << 8) ^ + ((uint32_t)FSb[(Y3 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y0 >> 24) & 0xFF] << 24); - X2 = *RK++ ^ \ - ( (uint32_t) FSb[ ( Y2 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( Y3 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( Y0 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( Y1 >> 24 ) & 0xFF ] << 24 ); + X2 = *RK++ ^ ((uint32_t)FSb[(Y2)&0xFF]) ^ ((uint32_t)FSb[(Y3 >> 8) & 0xFF] << 8) ^ + ((uint32_t)FSb[(Y0 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y1 >> 24) & 0xFF] << 24); - X3 = *RK++ ^ \ - ( (uint32_t) FSb[ ( Y3 ) & 0xFF ] ) ^ - ( (uint32_t) FSb[ ( Y0 >> 8 ) & 0xFF ] << 8 ) ^ - ( (uint32_t) FSb[ ( Y1 >> 16 ) & 0xFF ] << 16 ) ^ - ( (uint32_t) FSb[ ( Y2 >> 24 ) & 0xFF ] << 24 ); + X3 = *RK++ ^ ((uint32_t)FSb[(Y3)&0xFF]) ^ ((uint32_t)FSb[(Y0 >> 8) & 0xFF] << 8) ^ + ((uint32_t)FSb[(Y1 >> 16) & 0xFF] << 16) ^ ((uint32_t)FSb[(Y2 >> 24) & 0xFF] << 24); -#if AES_DECRYPTION // whether AES decryption is supported +#if AES_DECRYPTION // whether AES decryption is supported } #endif /* AES_DECRYPTION */ - PUT_UINT32_LE( X0, output, 0 ); - PUT_UINT32_LE( X1, output, 4 ); - PUT_UINT32_LE( X2, output, 8 ); - PUT_UINT32_LE( X3, output, 12 ); + PUT_UINT32_LE(X0, output, 0); + PUT_UINT32_LE(X1, output, 4); + PUT_UINT32_LE(X2, output, 8); + PUT_UINT32_LE(X3, output, 12); - return( 0 ); + return (0); } /* end of aes.c */ diff --git a/applications/external/esubghz_chat/crypto/aes.h b/applications/external/esubghz_chat/crypto/aes.h index d4d28db52..a7c405438 100644 --- a/applications/external/esubghz_chat/crypto/aes.h +++ b/applications/external/esubghz_chat/crypto/aes.h @@ -24,58 +24,57 @@ #define AES_HEADER /******************************************************************************/ -#define AES_DECRYPTION 0 // whether AES decryption is supported +#define AES_DECRYPTION 0 // whether AES decryption is supported /******************************************************************************/ #include -#define ENCRYPT 1 // specify whether we're encrypting -#define DECRYPT 0 // or decrypting +#define ENCRYPT 1 // specify whether we're encrypting +#define DECRYPT 0 // or decrypting #if defined(_MSC_VER) - #include - typedef UINT32 uint32_t; +#include +typedef UINT32 uint32_t; #else - #include +#include #endif -typedef unsigned char uchar; // add some convienent shorter types +typedef unsigned char uchar; // add some convienent shorter types typedef unsigned int uint; - /****************************************************************************** * AES_INIT_KEYGEN_TABLES : MUST be called once before any AES use ******************************************************************************/ -void aes_init_keygen_tables( void ); - +void aes_init_keygen_tables(void); /****************************************************************************** * AES_CONTEXT : cipher context / holds inter-call data ******************************************************************************/ typedef struct { - int mode; // 1 for Encryption, 0 for Decryption - int rounds; // keysize-based rounds count - uint32_t *rk; // pointer to current round key - uint32_t buf[68]; // key expansion buffer + int mode; // 1 for Encryption, 0 for Decryption + int rounds; // keysize-based rounds count + uint32_t* rk; // pointer to current round key + uint32_t buf[68]; // key expansion buffer } aes_context; - /****************************************************************************** * AES_SETKEY : called to expand the key for encryption or decryption ******************************************************************************/ -int aes_setkey( aes_context *ctx, // pointer to context - int mode, // 1 or 0 for Encrypt/Decrypt - const uchar *key, // AES input key - uint keysize ); // size in bytes (must be 16, 24, 32 for - // 128, 192 or 256-bit keys respectively) - // returns 0 for success +int aes_setkey( + aes_context* ctx, // pointer to context + int mode, // 1 or 0 for Encrypt/Decrypt + const uchar* key, // AES input key + uint keysize); // size in bytes (must be 16, 24, 32 for + // 128, 192 or 256-bit keys respectively) + // returns 0 for success /****************************************************************************** * AES_CIPHER : called to encrypt or decrypt ONE 128-bit block of data ******************************************************************************/ -int aes_cipher( aes_context *ctx, // pointer to context - const uchar input[16], // 128-bit block to en/decipher - uchar output[16] ); // 128-bit output result block - // returns 0 for success +int aes_cipher( + aes_context* ctx, // pointer to context + const uchar input[16], // 128-bit block to en/decipher + uchar output[16]); // 128-bit output result block + // returns 0 for success #endif /* AES_HEADER */ diff --git a/applications/external/esubghz_chat/crypto/gcm.c b/applications/external/esubghz_chat/crypto/gcm.c index 6b1cba211..c5aad7aa4 100644 --- a/applications/external/esubghz_chat/crypto/gcm.c +++ b/applications/external/esubghz_chat/crypto/gcm.c @@ -76,25 +76,40 @@ * significantly slower 128x128 bit multiple within GF(2^128). */ static const uint64_t last4[16] = { - 0x0000, 0x1c20, 0x3840, 0x2460, 0x7080, 0x6ca0, 0x48c0, 0x54e0, - 0xe100, 0xfd20, 0xd940, 0xc560, 0x9180, 0x8da0, 0xa9c0, 0xb5e0 }; + 0x0000, + 0x1c20, + 0x3840, + 0x2460, + 0x7080, + 0x6ca0, + 0x48c0, + 0x54e0, + 0xe100, + 0xfd20, + 0xd940, + 0xc560, + 0x9180, + 0x8da0, + 0xa9c0, + 0xb5e0}; /* * Platform Endianness Neutralizing Load and Store Macro definitions * GCM wants platform-neutral Big Endian (BE) byte ordering */ -#define GET_UINT32_BE(n,b,i) { \ - (n) = ( (uint32_t) (b)[(i) ] << 24 ) \ - | ( (uint32_t) (b)[(i) + 1] << 16 ) \ - | ( (uint32_t) (b)[(i) + 2] << 8 ) \ - | ( (uint32_t) (b)[(i) + 3] ); } - -#define PUT_UINT32_BE(n,b,i) { \ - (b)[(i) ] = (uchar) ( (n) >> 24 ); \ - (b)[(i) + 1] = (uchar) ( (n) >> 16 ); \ - (b)[(i) + 2] = (uchar) ( (n) >> 8 ); \ - (b)[(i) + 3] = (uchar) ( (n) ); } +#define GET_UINT32_BE(n, b, i) \ + { \ + (n) = ((uint32_t)(b)[(i)] << 24) | ((uint32_t)(b)[(i) + 1] << 16) | \ + ((uint32_t)(b)[(i) + 2] << 8) | ((uint32_t)(b)[(i) + 3]); \ + } +#define PUT_UINT32_BE(n, b, i) \ + { \ + (b)[(i)] = (uchar)((n) >> 24); \ + (b)[(i) + 1] = (uchar)((n) >> 16); \ + (b)[(i) + 2] = (uchar)((n) >> 8); \ + (b)[(i) + 3] = (uchar)((n)); \ + } /****************************************************************************** * @@ -108,13 +123,11 @@ static const uint64_t last4[16] = { * environment is running. * ******************************************************************************/ -int gcm_initialize( void ) -{ +int gcm_initialize(void) { aes_init_keygen_tables(); - return( 0 ); + return (0); } - /****************************************************************************** * * GCM_MULT @@ -124,45 +137,45 @@ int gcm_initialize( void ) * 'x' and 'output' are seen as elements of GCM's GF(2^128) Galois field. * ******************************************************************************/ -static void gcm_mult( gcm_context *ctx, // pointer to established context - const uchar x[16], // pointer to 128-bit input vector - uchar output[16] ) // pointer to 128-bit output vector +static void gcm_mult( + gcm_context* ctx, // pointer to established context + const uchar x[16], // pointer to 128-bit input vector + uchar output[16]) // pointer to 128-bit output vector { int i; uchar lo, hi, rem; uint64_t zh, zl; - lo = (uchar)( x[15] & 0x0f ); - hi = (uchar)( x[15] >> 4 ); + lo = (uchar)(x[15] & 0x0f); + hi = (uchar)(x[15] >> 4); zh = ctx->HH[lo]; zl = ctx->HL[lo]; - for( i = 15; i >= 0; i-- ) { - lo = (uchar) ( x[i] & 0x0f ); - hi = (uchar) ( x[i] >> 4 ); + for(i = 15; i >= 0; i--) { + lo = (uchar)(x[i] & 0x0f); + hi = (uchar)(x[i] >> 4); - if( i != 15 ) { - rem = (uchar) ( zl & 0x0f ); - zl = ( zh << 60 ) | ( zl >> 4 ); - zh = ( zh >> 4 ); - zh ^= (uint64_t) last4[rem] << 48; + if(i != 15) { + rem = (uchar)(zl & 0x0f); + zl = (zh << 60) | (zl >> 4); + zh = (zh >> 4); + zh ^= (uint64_t)last4[rem] << 48; zh ^= ctx->HH[lo]; zl ^= ctx->HL[lo]; } - rem = (uchar) ( zl & 0x0f ); - zl = ( zh << 60 ) | ( zl >> 4 ); - zh = ( zh >> 4 ); - zh ^= (uint64_t) last4[rem] << 48; + rem = (uchar)(zl & 0x0f); + zl = (zh << 60) | (zl >> 4); + zh = (zh >> 4); + zh ^= (uint64_t)last4[rem] << 48; zh ^= ctx->HH[hi]; zl ^= ctx->HL[hi]; } - PUT_UINT32_BE( zh >> 32, output, 0 ); - PUT_UINT32_BE( zh, output, 4 ); - PUT_UINT32_BE( zl >> 32, output, 8 ); - PUT_UINT32_BE( zl, output, 12 ); + PUT_UINT32_BE(zh >> 32, output, 0); + PUT_UINT32_BE(zh, output, 4); + PUT_UINT32_BE(zl >> 32, output, 8); + PUT_UINT32_BE(zl, output, 12); } - /****************************************************************************** * * GCM_SETKEY @@ -171,59 +184,57 @@ static void gcm_mult( gcm_context *ctx, // pointer to established context * and populates the gcm context's pre-calculated HTables. * ******************************************************************************/ -int gcm_setkey( gcm_context *ctx, // pointer to caller-provided gcm context - const uchar *key, // pointer to the AES encryption key - const uint keysize) // size in bytes (must be 16, 24, 32 for - // 128, 192 or 256-bit keys respectively) +int gcm_setkey( + gcm_context* ctx, // pointer to caller-provided gcm context + const uchar* key, // pointer to the AES encryption key + const uint keysize) // size in bytes (must be 16, 24, 32 for +// 128, 192 or 256-bit keys respectively) { int ret, i, j; uint64_t hi, lo; uint64_t vl, vh; unsigned char h[16]; - memset( ctx, 0, sizeof(gcm_context) ); // zero caller-provided GCM context - memset( h, 0, 16 ); // initialize the block to encrypt + memset(ctx, 0, sizeof(gcm_context)); // zero caller-provided GCM context + memset(h, 0, 16); // initialize the block to encrypt // encrypt the null 128-bit block to generate a key-based value // which is then used to initialize our GHASH lookup tables - if(( ret = aes_setkey( &ctx->aes_ctx, ENCRYPT, key, keysize )) != 0 ) - return( ret ); - if(( ret = aes_cipher( &ctx->aes_ctx, h, h )) != 0 ) - return( ret ); + if((ret = aes_setkey(&ctx->aes_ctx, ENCRYPT, key, keysize)) != 0) return (ret); + if((ret = aes_cipher(&ctx->aes_ctx, h, h)) != 0) return (ret); - GET_UINT32_BE( hi, h, 0 ); // pack h as two 64-bit ints, big-endian - GET_UINT32_BE( lo, h, 4 ); - vh = (uint64_t) hi << 32 | lo; + GET_UINT32_BE(hi, h, 0); // pack h as two 64-bit ints, big-endian + GET_UINT32_BE(lo, h, 4); + vh = (uint64_t)hi << 32 | lo; - GET_UINT32_BE( hi, h, 8 ); - GET_UINT32_BE( lo, h, 12 ); - vl = (uint64_t) hi << 32 | lo; + GET_UINT32_BE(hi, h, 8); + GET_UINT32_BE(lo, h, 12); + vl = (uint64_t)hi << 32 | lo; - ctx->HL[8] = vl; // 8 = 1000 corresponds to 1 in GF(2^128) + ctx->HL[8] = vl; // 8 = 1000 corresponds to 1 in GF(2^128) ctx->HH[8] = vh; - ctx->HH[0] = 0; // 0 corresponds to 0 in GF(2^128) + ctx->HH[0] = 0; // 0 corresponds to 0 in GF(2^128) ctx->HL[0] = 0; - for( i = 4; i > 0; i >>= 1 ) { - uint32_t T = (uint32_t) ( vl & 1 ) * 0xe1000000U; - vl = ( vh << 63 ) | ( vl >> 1 ); - vh = ( vh >> 1 ) ^ ( (uint64_t) T << 32); + for(i = 4; i > 0; i >>= 1) { + uint32_t T = (uint32_t)(vl & 1) * 0xe1000000U; + vl = (vh << 63) | (vl >> 1); + vh = (vh >> 1) ^ ((uint64_t)T << 32); ctx->HL[i] = vl; ctx->HH[i] = vh; } - for (i = 2; i < 16; i <<= 1 ) { + for(i = 2; i < 16; i <<= 1) { uint64_t *HiL = ctx->HL + i, *HiH = ctx->HH + i; vh = *HiH; vl = *HiL; - for( j = 1; j < i; j++ ) { + for(j = 1; j < i; j++) { HiH[j] = vh ^ ctx->HH[j]; HiL[j] = vl ^ ctx->HL[j]; } } - return( 0 ); + return (0); } - /****************************************************************************** * * GCM processing occurs four phases: SETKEY, START, UPDATE and FINISH. @@ -245,62 +256,61 @@ int gcm_setkey( gcm_context *ctx, // pointer to caller-provided gcm context * mode, and preprocesses the initialization vector and additional AEAD data. * ******************************************************************************/ -int gcm_start( gcm_context *ctx, // pointer to user-provided GCM context - int mode, // GCM_ENCRYPT or GCM_DECRYPT - const uchar *iv, // pointer to initialization vector - size_t iv_len, // IV length in bytes (should == 12) - const uchar *add, // ptr to additional AEAD data (NULL if none) - size_t add_len ) // length of additional AEAD data (bytes) +int gcm_start( + gcm_context* ctx, // pointer to user-provided GCM context + int mode, // GCM_ENCRYPT or GCM_DECRYPT + const uchar* iv, // pointer to initialization vector + size_t iv_len, // IV length in bytes (should == 12) + const uchar* add, // ptr to additional AEAD data (NULL if none) + size_t add_len) // length of additional AEAD data (bytes) { - int ret; // our error return if the AES encrypt fails + int ret; // our error return if the AES encrypt fails uchar work_buf[16]; // XOR source built from provided IV if len != 16 - const uchar *p; // general purpose array pointer - size_t use_len; // byte count to process, up to 16 bytes - size_t i; // local loop iterator + const uchar* p; // general purpose array pointer + size_t use_len; // byte count to process, up to 16 bytes + size_t i; // local loop iterator // since the context might be reused under the same key // we zero the working buffers for this next new process - memset( ctx->y, 0x00, sizeof(ctx->y ) ); - memset( ctx->buf, 0x00, sizeof(ctx->buf) ); + memset(ctx->y, 0x00, sizeof(ctx->y)); + memset(ctx->buf, 0x00, sizeof(ctx->buf)); ctx->len = 0; ctx->add_len = 0; - ctx->mode = mode; // set the GCM encryption/decryption mode - ctx->aes_ctx.mode = ENCRYPT; // GCM *always* runs AES in ENCRYPTION mode + ctx->mode = mode; // set the GCM encryption/decryption mode + ctx->aes_ctx.mode = ENCRYPT; // GCM *always* runs AES in ENCRYPTION mode - if( iv_len == 12 ) { // GCM natively uses a 12-byte, 96-bit IV - memcpy( ctx->y, iv, iv_len ); // copy the IV to the top of the 'y' buff - ctx->y[15] = 1; // start "counting" from 1 (not 0) - } - else // if we don't have a 12-byte IV, we GHASH whatever we've been given - { - memset( work_buf, 0x00, 16 ); // clear the working buffer - PUT_UINT32_BE( iv_len * 8, work_buf, 12 ); // place the IV into buffer + if(iv_len == 12) { // GCM natively uses a 12-byte, 96-bit IV + memcpy(ctx->y, iv, iv_len); // copy the IV to the top of the 'y' buff + ctx->y[15] = 1; // start "counting" from 1 (not 0) + } else // if we don't have a 12-byte IV, we GHASH whatever we've been given + { + memset(work_buf, 0x00, 16); // clear the working buffer + PUT_UINT32_BE(iv_len * 8, work_buf, 12); // place the IV into buffer p = iv; - while( iv_len > 0 ) { - use_len = ( iv_len < 16 ) ? iv_len : 16; - for( i = 0; i < use_len; i++ ) ctx->y[i] ^= p[i]; - gcm_mult( ctx, ctx->y, ctx->y ); + while(iv_len > 0) { + use_len = (iv_len < 16) ? iv_len : 16; + for(i = 0; i < use_len; i++) ctx->y[i] ^= p[i]; + gcm_mult(ctx, ctx->y, ctx->y); iv_len -= use_len; p += use_len; } - for( i = 0; i < 16; i++ ) ctx->y[i] ^= work_buf[i]; - gcm_mult( ctx, ctx->y, ctx->y ); + for(i = 0; i < 16; i++) ctx->y[i] ^= work_buf[i]; + gcm_mult(ctx, ctx->y, ctx->y); } - if( ( ret = aes_cipher( &ctx->aes_ctx, ctx->y, ctx->base_ectr ) ) != 0 ) - return( ret ); + if((ret = aes_cipher(&ctx->aes_ctx, ctx->y, ctx->base_ectr)) != 0) return (ret); ctx->add_len = add_len; p = add; - while( add_len > 0 ) { - use_len = ( add_len < 16 ) ? add_len : 16; - for( i = 0; i < use_len; i++ ) ctx->buf[i] ^= p[i]; - gcm_mult( ctx, ctx->buf, ctx->buf ); + while(add_len > 0) { + use_len = (add_len < 16) ? add_len : 16; + for(i = 0; i < use_len; i++) ctx->buf[i] ^= p[i]; + gcm_mult(ctx, ctx->buf, ctx->buf); add_len -= use_len; p += use_len; } - return( 0 ); + return (0); } /****************************************************************************** @@ -314,63 +324,61 @@ int gcm_start( gcm_context *ctx, // pointer to user-provided GCM context * have a partial block length of < 128 bits.) * ******************************************************************************/ -int gcm_update( gcm_context *ctx, // pointer to user-provided GCM context - size_t length, // length, in bytes, of data to process - const uchar *input, // pointer to source data - uchar *output ) // pointer to destination data +int gcm_update( + gcm_context* ctx, // pointer to user-provided GCM context + size_t length, // length, in bytes, of data to process + const uchar* input, // pointer to source data + uchar* output) // pointer to destination data { - int ret; // our error return if the AES encrypt fails - uchar ectr[16]; // counter-mode cipher output for XORing - size_t use_len; // byte count to process, up to 16 bytes - size_t i; // local loop iterator + int ret; // our error return if the AES encrypt fails + uchar ectr[16]; // counter-mode cipher output for XORing + size_t use_len; // byte count to process, up to 16 bytes + size_t i; // local loop iterator ctx->len += length; // bump the GCM context's running length count - while( length > 0 ) { + while(length > 0) { // clamp the length to process at 16 bytes - use_len = ( length < 16 ) ? length : 16; + use_len = (length < 16) ? length : 16; // increment the context's 128-bit IV||Counter 'y' vector - for( i = 16; i > 12; i-- ) if( ++ctx->y[i - 1] != 0 ) break; + for(i = 16; i > 12; i--) + if(++ctx->y[i - 1] != 0) break; // encrypt the context's 'y' vector under the established key - if( ( ret = aes_cipher( &ctx->aes_ctx, ctx->y, ectr ) ) != 0 ) - return( ret ); + if((ret = aes_cipher(&ctx->aes_ctx, ctx->y, ectr)) != 0) return (ret); // encrypt or decrypt the input to the output - if( ctx->mode == ENCRYPT ) - { - for( i = 0; i < use_len; i++ ) { + if(ctx->mode == ENCRYPT) { + for(i = 0; i < use_len; i++) { // XOR the cipher's ouptut vector (ectr) with our input - output[i] = (uchar) ( ectr[i] ^ input[i] ); + output[i] = (uchar)(ectr[i] ^ input[i]); // now we mix in our data into the authentication hash. - // if we're ENcrypting we XOR in the post-XOR (output) - // results, but if we're DEcrypting we XOR in the input + // if we're ENcrypting we XOR in the post-XOR (output) + // results, but if we're DEcrypting we XOR in the input // data ctx->buf[i] ^= output[i]; } - } - else - { - for( i = 0; i < use_len; i++ ) { - // but if we're DEcrypting we XOR in the input data first, - // i.e. before saving to ouput data, otherwise if the input - // and output buffer are the same (inplace decryption) we + } else { + for(i = 0; i < use_len; i++) { + // but if we're DEcrypting we XOR in the input data first, + // i.e. before saving to ouput data, otherwise if the input + // and output buffer are the same (inplace decryption) we // would not get the correct auth tag - ctx->buf[i] ^= input[i]; + ctx->buf[i] ^= input[i]; // XOR the cipher's ouptut vector (ectr) with our input - output[i] = (uchar) ( ectr[i] ^ input[i] ); - } + output[i] = (uchar)(ectr[i] ^ input[i]); + } } - gcm_mult( ctx, ctx->buf, ctx->buf ); // perform a GHASH operation + gcm_mult(ctx, ctx->buf, ctx->buf); // perform a GHASH operation - length -= use_len; // drop the remaining byte count to process - input += use_len; // bump our input pointer forward - output += use_len; // bump our output pointer forward + length -= use_len; // drop the remaining byte count to process + input += use_len; // bump our input pointer forward + output += use_len; // bump our output pointer forward } - return( 0 ); + return (0); } /****************************************************************************** @@ -381,33 +389,33 @@ int gcm_update( gcm_context *ctx, // pointer to user-provided GCM context * It performs the final GHASH to produce the resulting authentication TAG. * ******************************************************************************/ -int gcm_finish( gcm_context *ctx, // pointer to user-provided GCM context - uchar *tag, // pointer to buffer which receives the tag - size_t tag_len ) // length, in bytes, of the tag-receiving buf +int gcm_finish( + gcm_context* ctx, // pointer to user-provided GCM context + uchar* tag, // pointer to buffer which receives the tag + size_t tag_len) // length, in bytes, of the tag-receiving buf { uchar work_buf[16]; - uint64_t orig_len = ctx->len * 8; + uint64_t orig_len = ctx->len * 8; uint64_t orig_add_len = ctx->add_len * 8; size_t i; - if( tag_len != 0 ) memcpy( tag, ctx->base_ectr, tag_len ); + if(tag_len != 0) memcpy(tag, ctx->base_ectr, tag_len); - if( orig_len || orig_add_len ) { - memset( work_buf, 0x00, 16 ); + if(orig_len || orig_add_len) { + memset(work_buf, 0x00, 16); - PUT_UINT32_BE( ( orig_add_len >> 32 ), work_buf, 0 ); - PUT_UINT32_BE( ( orig_add_len ), work_buf, 4 ); - PUT_UINT32_BE( ( orig_len >> 32 ), work_buf, 8 ); - PUT_UINT32_BE( ( orig_len ), work_buf, 12 ); + PUT_UINT32_BE((orig_add_len >> 32), work_buf, 0); + PUT_UINT32_BE((orig_add_len), work_buf, 4); + PUT_UINT32_BE((orig_len >> 32), work_buf, 8); + PUT_UINT32_BE((orig_len), work_buf, 12); - for( i = 0; i < 16; i++ ) ctx->buf[i] ^= work_buf[i]; - gcm_mult( ctx, ctx->buf, ctx->buf ); - for( i = 0; i < tag_len; i++ ) tag[i] ^= ctx->buf[i]; + for(i = 0; i < 16; i++) ctx->buf[i] ^= work_buf[i]; + gcm_mult(ctx, ctx->buf, ctx->buf); + for(i = 0; i < tag_len; i++) tag[i] ^= ctx->buf[i]; } - return( 0 ); + return (0); } - /****************************************************************************** * * GCM_CRYPT_AND_TAG @@ -426,29 +434,28 @@ int gcm_finish( gcm_context *ctx, // pointer to user-provided GCM context * ******************************************************************************/ int gcm_crypt_and_tag( - gcm_context *ctx, // gcm context with key already setup - int mode, // cipher direction: GCM_ENCRYPT or GCM_DECRYPT - const uchar *iv, // pointer to the 12-byte initialization vector - size_t iv_len, // byte length if the IV. should always be 12 - const uchar *add, // pointer to the non-ciphered additional data - size_t add_len, // byte length of the additional AEAD data - const uchar *input, // pointer to the cipher data source - uchar *output, // pointer to the cipher data destination - size_t length, // byte length of the cipher data - uchar *tag, // pointer to the tag to be generated - size_t tag_len ) // byte length of the tag to be generated -{ /* + gcm_context* ctx, // gcm context with key already setup + int mode, // cipher direction: GCM_ENCRYPT or GCM_DECRYPT + const uchar* iv, // pointer to the 12-byte initialization vector + size_t iv_len, // byte length if the IV. should always be 12 + const uchar* add, // pointer to the non-ciphered additional data + size_t add_len, // byte length of the additional AEAD data + const uchar* input, // pointer to the cipher data source + uchar* output, // pointer to the cipher data destination + size_t length, // byte length of the cipher data + uchar* tag, // pointer to the tag to be generated + size_t tag_len) // byte length of the tag to be generated +{ /* assuming that the caller has already invoked gcm_setkey to prepare the gcm context with the keying material, we simply invoke each of the three GCM sub-functions in turn... */ - gcm_start ( ctx, mode, iv, iv_len, add, add_len ); - gcm_update ( ctx, length, input, output ); - gcm_finish ( ctx, tag, tag_len ); - return( 0 ); + gcm_start(ctx, mode, iv, iv_len, add, add_len); + gcm_update(ctx, length, input, output); + gcm_finish(ctx, tag, tag_len); + return (0); } - /****************************************************************************** * * GCM_AUTH_DECRYPT @@ -462,37 +469,36 @@ int gcm_crypt_and_tag( * ******************************************************************************/ int gcm_auth_decrypt( - gcm_context *ctx, // gcm context with key already setup - const uchar *iv, // pointer to the 12-byte initialization vector - size_t iv_len, // byte length if the IV. should always be 12 - const uchar *add, // pointer to the non-ciphered additional data - size_t add_len, // byte length of the additional AEAD data - const uchar *input, // pointer to the cipher data source - uchar *output, // pointer to the cipher data destination - size_t length, // byte length of the cipher data - const uchar *tag, // pointer to the tag to be authenticated - size_t tag_len ) // byte length of the tag <= 16 + gcm_context* ctx, // gcm context with key already setup + const uchar* iv, // pointer to the 12-byte initialization vector + size_t iv_len, // byte length if the IV. should always be 12 + const uchar* add, // pointer to the non-ciphered additional data + size_t add_len, // byte length of the additional AEAD data + const uchar* input, // pointer to the cipher data source + uchar* output, // pointer to the cipher data destination + size_t length, // byte length of the cipher data + const uchar* tag, // pointer to the tag to be authenticated + size_t tag_len) // byte length of the tag <= 16 { - uchar check_tag[16]; // the tag generated and returned by decryption - int diff; // an ORed flag to detect authentication errors - size_t i; // our local iterator + uchar check_tag[16]; // the tag generated and returned by decryption + int diff; // an ORed flag to detect authentication errors + size_t i; // our local iterator /* we use GCM_DECRYPT_AND_TAG (above) to perform our decryption (which is an identical XORing to reverse the previous one) and also to re-generate the matching authentication tag */ - gcm_crypt_and_tag( ctx, DECRYPT, iv, iv_len, add, add_len, - input, output, length, check_tag, tag_len ); + gcm_crypt_and_tag( + ctx, DECRYPT, iv, iv_len, add, add_len, input, output, length, check_tag, tag_len); // now we verify the authentication tag in 'constant time' - for( diff = 0, i = 0; i < tag_len; i++ ) - diff |= tag[i] ^ check_tag[i]; + for(diff = 0, i = 0; i < tag_len; i++) diff |= tag[i] ^ check_tag[i]; - if( diff != 0 ) { // see whether any bits differed? - memset( output, 0, length ); // if so... wipe the output data - return( GCM_AUTH_FAILURE ); // return GCM_AUTH_FAILURE + if(diff != 0) { // see whether any bits differed? + memset(output, 0, length); // if so... wipe the output data + return (GCM_AUTH_FAILURE); // return GCM_AUTH_FAILURE } - return( 0 ); + return (0); } /****************************************************************************** @@ -504,8 +510,7 @@ int gcm_auth_decrypt( * sensitive, so it MUST be zeroed after use. This function does that. * ******************************************************************************/ -void gcm_zero_ctx( gcm_context *ctx ) -{ +void gcm_zero_ctx(gcm_context* ctx) { // zero the context originally provided to us - memset( ctx, 0, sizeof( gcm_context ) ); + memset(ctx, 0, sizeof(gcm_context)); } diff --git a/applications/external/esubghz_chat/crypto/gcm.h b/applications/external/esubghz_chat/crypto/gcm.h index 063154195..9a3e47052 100644 --- a/applications/external/esubghz_chat/crypto/gcm.h +++ b/applications/external/esubghz_chat/crypto/gcm.h @@ -24,52 +24,49 @@ #ifndef GCM_HEADER #define GCM_HEADER -#define GCM_AUTH_FAILURE 0x55555555 // authentication failure +#define GCM_AUTH_FAILURE 0x55555555 // authentication failure -#include "aes.h" // gcm_context includes aes_context +#include "aes.h" // gcm_context includes aes_context #if defined(_MSC_VER) - #include - typedef unsigned int size_t;// use the right type for length declarations - typedef UINT32 uint32_t; - typedef UINT64 uint64_t; +#include +typedef unsigned int size_t; // use the right type for length declarations +typedef UINT32 uint32_t; +typedef UINT64 uint64_t; #else - #include +#include #endif - /****************************************************************************** * GCM_CONTEXT : GCM context / holds keytables, instance data, and AES ctx ******************************************************************************/ typedef struct { - int mode; // cipher direction: encrypt/decrypt - uint64_t len; // cipher data length processed so far - uint64_t add_len; // total add data length - uint64_t HL[16]; // precalculated lo-half HTable - uint64_t HH[16]; // precalculated hi-half HTable - uchar base_ectr[16]; // first counter-mode cipher output for tag - uchar y[16]; // the current cipher-input IV|Counter value - uchar buf[16]; // buf working value - aes_context aes_ctx; // cipher context used + int mode; // cipher direction: encrypt/decrypt + uint64_t len; // cipher data length processed so far + uint64_t add_len; // total add data length + uint64_t HL[16]; // precalculated lo-half HTable + uint64_t HH[16]; // precalculated hi-half HTable + uchar base_ectr[16]; // first counter-mode cipher output for tag + uchar y[16]; // the current cipher-input IV|Counter value + uchar buf[16]; // buf working value + aes_context aes_ctx; // cipher context used } gcm_context; - /****************************************************************************** * GCM_CONTEXT : MUST be called once before ANY use of this library ******************************************************************************/ -int gcm_initialize( void ); - +int gcm_initialize(void); /****************************************************************************** * GCM_SETKEY : sets the GCM (and AES) keying material for use ******************************************************************************/ -int gcm_setkey( gcm_context *ctx, // caller-provided context ptr - const uchar *key, // pointer to cipher key - const uint keysize // size in bytes (must be 16, 24, 32 for - // 128, 192 or 256-bit keys respectively) +int gcm_setkey( + gcm_context* ctx, // caller-provided context ptr + const uchar* key, // pointer to cipher key + const uint keysize // size in bytes (must be 16, 24, 32 for + // 128, 192 or 256-bit keys respectively) ); // returns 0 for success - /****************************************************************************** * * GCM_CRYPT_AND_TAG @@ -88,18 +85,17 @@ int gcm_setkey( gcm_context *ctx, // caller-provided context ptr * ******************************************************************************/ int gcm_crypt_and_tag( - gcm_context *ctx, // gcm context with key already setup - int mode, // cipher direction: ENCRYPT (1) or DECRYPT (0) - const uchar *iv, // pointer to the 12-byte initialization vector - size_t iv_len, // byte length if the IV. should always be 12 - const uchar *add, // pointer to the non-ciphered additional data - size_t add_len, // byte length of the additional AEAD data - const uchar *input, // pointer to the cipher data source - uchar *output, // pointer to the cipher data destination - size_t length, // byte length of the cipher data - uchar *tag, // pointer to the tag to be generated - size_t tag_len ); // byte length of the tag to be generated - + gcm_context* ctx, // gcm context with key already setup + int mode, // cipher direction: ENCRYPT (1) or DECRYPT (0) + const uchar* iv, // pointer to the 12-byte initialization vector + size_t iv_len, // byte length if the IV. should always be 12 + const uchar* add, // pointer to the non-ciphered additional data + size_t add_len, // byte length of the additional AEAD data + const uchar* input, // pointer to the cipher data source + uchar* output, // pointer to the cipher data destination + size_t length, // byte length of the cipher data + uchar* tag, // pointer to the tag to be generated + size_t tag_len); // byte length of the tag to be generated /****************************************************************************** * @@ -114,17 +110,16 @@ int gcm_crypt_and_tag( * ******************************************************************************/ int gcm_auth_decrypt( - gcm_context *ctx, // gcm context with key already setup - const uchar *iv, // pointer to the 12-byte initialization vector - size_t iv_len, // byte length if the IV. should always be 12 - const uchar *add, // pointer to the non-ciphered additional data - size_t add_len, // byte length of the additional AEAD data - const uchar *input, // pointer to the cipher data source - uchar *output, // pointer to the cipher data destination - size_t length, // byte length of the cipher data - const uchar *tag, // pointer to the tag to be authenticated - size_t tag_len ); // byte length of the tag <= 16 - + gcm_context* ctx, // gcm context with key already setup + const uchar* iv, // pointer to the 12-byte initialization vector + size_t iv_len, // byte length if the IV. should always be 12 + const uchar* add, // pointer to the non-ciphered additional data + size_t add_len, // byte length of the additional AEAD data + const uchar* input, // pointer to the cipher data source + uchar* output, // pointer to the cipher data destination + size_t length, // byte length of the cipher data + const uchar* tag, // pointer to the tag to be authenticated + size_t tag_len); // byte length of the tag <= 16 /****************************************************************************** * @@ -134,13 +129,13 @@ int gcm_auth_decrypt( * mode, and preprocesses the initialization vector and additional AEAD data. * ******************************************************************************/ -int gcm_start( gcm_context *ctx, // pointer to user-provided GCM context - int mode, // ENCRYPT (1) or DECRYPT (0) - const uchar *iv, // pointer to initialization vector - size_t iv_len, // IV length in bytes (should == 12) - const uchar *add, // pointer to additional AEAD data (NULL if none) - size_t add_len ); // length of additional AEAD data (bytes) - +int gcm_start( + gcm_context* ctx, // pointer to user-provided GCM context + int mode, // ENCRYPT (1) or DECRYPT (0) + const uchar* iv, // pointer to initialization vector + size_t iv_len, // IV length in bytes (should == 12) + const uchar* add, // pointer to additional AEAD data (NULL if none) + size_t add_len); // length of additional AEAD data (bytes) /****************************************************************************** * @@ -153,11 +148,11 @@ int gcm_start( gcm_context *ctx, // pointer to user-provided GCM context * have a partial block length of < 128 bits.) * ******************************************************************************/ -int gcm_update( gcm_context *ctx, // pointer to user-provided GCM context - size_t length, // length, in bytes, of data to process - const uchar *input, // pointer to source data - uchar *output ); // pointer to destination data - +int gcm_update( + gcm_context* ctx, // pointer to user-provided GCM context + size_t length, // length, in bytes, of data to process + const uchar* input, // pointer to source data + uchar* output); // pointer to destination data /****************************************************************************** * @@ -167,10 +162,10 @@ int gcm_update( gcm_context *ctx, // pointer to user-provided GCM context * It performs the final GHASH to produce the resulting authentication TAG. * ******************************************************************************/ -int gcm_finish( gcm_context *ctx, // pointer to user-provided GCM context - uchar *tag, // ptr to tag buffer - NULL if tag_len = 0 - size_t tag_len ); // length, in bytes, of the tag-receiving buf - +int gcm_finish( + gcm_context* ctx, // pointer to user-provided GCM context + uchar* tag, // ptr to tag buffer - NULL if tag_len = 0 + size_t tag_len); // length, in bytes, of the tag-receiving buf /****************************************************************************** * @@ -181,7 +176,6 @@ int gcm_finish( gcm_context *ctx, // pointer to user-provided GCM context * sensitive, so it MUST be zeroed after use. This function does that. * ******************************************************************************/ -void gcm_zero_ctx( gcm_context *ctx ); - +void gcm_zero_ctx(gcm_context* ctx); #endif /* GCM_HEADER */ diff --git a/applications/external/esubghz_chat/crypto_wrapper.c b/applications/external/esubghz_chat/crypto_wrapper.c index 397bc13d1..e9074bdce 100644 --- a/applications/external/esubghz_chat/crypto_wrapper.c +++ b/applications/external/esubghz_chat/crypto_wrapper.c @@ -11,181 +11,191 @@ DICT_DEF2(ESubGhzChatReplayDict, uint64_t, uint32_t) struct ESugGhzChatCryptoCtx { - uint8_t key[KEY_BITS / 8]; + uint8_t key[KEY_BITS / 8]; #ifndef FURI_HAL_CRYPTO_ADVANCED_AVAIL - gcm_context gcm_ctx; + gcm_context gcm_ctx; #endif /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - ESubGhzChatReplayDict_t replay_dict; - uint64_t run_id; - uint32_t counter; + ESubGhzChatReplayDict_t replay_dict; + uint64_t run_id; + uint32_t counter; }; struct ESubGhzChatCryptoMsg { - uint64_t run_id; - uint32_t counter; - uint8_t iv[IV_BYTES]; - uint8_t tag[TAG_BYTES]; - uint8_t data[0]; -} __attribute__ ((packed)); + uint64_t run_id; + uint32_t counter; + uint8_t iv[IV_BYTES]; + uint8_t tag[TAG_BYTES]; + uint8_t data[0]; +} __attribute__((packed)); -void crypto_init(void) -{ +void crypto_init(void) { #ifndef FURI_HAL_CRYPTO_ADVANCED_AVAIL - /* init the GCM and AES tables */ - gcm_initialize(); + /* init the GCM and AES tables */ + gcm_initialize(); #endif /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ } -void crypto_explicit_bzero(void *s, size_t len) -{ - memset(s, 0, len); - asm volatile("" ::: "memory"); +void crypto_explicit_bzero(void* s, size_t len) { + memset(s, 0, len); + asm volatile("" ::: "memory"); } -ESubGhzChatCryptoCtx *crypto_ctx_alloc(void) -{ - ESubGhzChatCryptoCtx *ret = malloc(sizeof(ESubGhzChatCryptoCtx)); +ESubGhzChatCryptoCtx* crypto_ctx_alloc(void) { + ESubGhzChatCryptoCtx* ret = malloc(sizeof(ESubGhzChatCryptoCtx)); - if (ret != NULL) { - memset(ret, 0, sizeof(ESubGhzChatCryptoCtx)); - ESubGhzChatReplayDict_init(ret->replay_dict); - ret->run_id = 0; - ret->counter = 1; - } + if(ret != NULL) { + memset(ret, 0, sizeof(ESubGhzChatCryptoCtx)); + ESubGhzChatReplayDict_init(ret->replay_dict); + ret->run_id = 0; + ret->counter = 1; + } - return ret; + return ret; } -void crypto_ctx_free(ESubGhzChatCryptoCtx *ctx) -{ - crypto_ctx_clear(ctx); - ESubGhzChatReplayDict_clear(ctx->replay_dict); - free(ctx); +void crypto_ctx_free(ESubGhzChatCryptoCtx* ctx) { + crypto_ctx_clear(ctx); + ESubGhzChatReplayDict_clear(ctx->replay_dict); + free(ctx); } -void crypto_ctx_clear(ESubGhzChatCryptoCtx *ctx) -{ - crypto_explicit_bzero(ctx->key, sizeof(ctx->key)); +void crypto_ctx_clear(ESubGhzChatCryptoCtx* ctx) { + crypto_explicit_bzero(ctx->key, sizeof(ctx->key)); #ifndef FURI_HAL_CRYPTO_ADVANCED_AVAIL - crypto_explicit_bzero(&(ctx->gcm_ctx), sizeof(ctx->gcm_ctx)); + crypto_explicit_bzero(&(ctx->gcm_ctx), sizeof(ctx->gcm_ctx)); #endif /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - ESubGhzChatReplayDict_reset(ctx->replay_dict); - ctx->run_id = 0; - ctx->counter = 1; + ESubGhzChatReplayDict_reset(ctx->replay_dict); + ctx->run_id = 0; + ctx->counter = 1; } -static uint64_t crypto_calc_run_id(FuriString *flipper_name, uint32_t tick) -{ - const char *fn = furi_string_get_cstr(flipper_name); - size_t fn_len = strlen(fn); +static uint64_t crypto_calc_run_id(FuriString* flipper_name, uint32_t tick) { + const char* fn = furi_string_get_cstr(flipper_name); + size_t fn_len = strlen(fn); - uint8_t h_in[fn_len + sizeof(uint32_t)]; - memcpy(h_in, fn, fn_len); - memcpy(h_in + fn_len, &tick, sizeof(uint32_t)); + uint8_t h_in[fn_len + sizeof(uint32_t)]; + memcpy(h_in, fn, fn_len); + memcpy(h_in + fn_len, &tick, sizeof(uint32_t)); - uint8_t h_out[256]; - sha256(h_in, fn_len + sizeof(uint32_t), h_out); + uint8_t h_out[256]; + sha256(h_in, fn_len + sizeof(uint32_t), h_out); - uint64_t run_id; - memcpy(&run_id, h_out, sizeof(uint64_t)); + uint64_t run_id; + memcpy(&run_id, h_out, sizeof(uint64_t)); - return run_id; + return run_id; } -bool crypto_ctx_set_key(ESubGhzChatCryptoCtx *ctx, const uint8_t *key, - FuriString *flipper_name, uint32_t tick) -{ - ctx->run_id = crypto_calc_run_id(flipper_name, tick); - ctx->counter = 1; +bool crypto_ctx_set_key( + ESubGhzChatCryptoCtx* ctx, + const uint8_t* key, + FuriString* flipper_name, + uint32_t tick) { + ctx->run_id = crypto_calc_run_id(flipper_name, tick); + ctx->counter = 1; - memcpy(ctx->key, key, KEY_BITS / 8); + memcpy(ctx->key, key, KEY_BITS / 8); #ifdef FURI_HAL_CRYPTO_ADVANCED_AVAIL - return true; + return true; #else /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - return (gcm_setkey(&(ctx->gcm_ctx), key, KEY_BITS / 8) == 0); + return (gcm_setkey(&(ctx->gcm_ctx), key, KEY_BITS / 8) == 0); #endif /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ } -void crypto_ctx_get_key(ESubGhzChatCryptoCtx *ctx, uint8_t *key) -{ - memcpy(key, ctx->key, KEY_BITS / 8); +void crypto_ctx_get_key(ESubGhzChatCryptoCtx* ctx, uint8_t* key) { + memcpy(key, ctx->key, KEY_BITS / 8); } -bool crypto_ctx_decrypt(ESubGhzChatCryptoCtx *ctx, uint8_t *in, size_t in_len, - uint8_t *out) -{ - if (in_len < MSG_OVERHEAD + 1) { - return false; - } +bool crypto_ctx_decrypt(ESubGhzChatCryptoCtx* ctx, uint8_t* in, size_t in_len, uint8_t* out) { + if(in_len < MSG_OVERHEAD + 1) { + return false; + } - struct ESubGhzChatCryptoMsg *msg = (struct ESubGhzChatCryptoMsg *) in; + struct ESubGhzChatCryptoMsg* msg = (struct ESubGhzChatCryptoMsg*)in; - // check if message is stale, if yes, discard - uint32_t *counter = ESubGhzChatReplayDict_get(ctx->replay_dict, - msg->run_id); - if (counter != NULL) { - if (*counter >= __ntohl(msg->counter)) { - return false; - } - } + // check if message is stale, if yes, discard + uint32_t* counter = ESubGhzChatReplayDict_get(ctx->replay_dict, msg->run_id); + if(counter != NULL) { + if(*counter >= __ntohl(msg->counter)) { + return false; + } + } - // decrypt and auth message + // decrypt and auth message #ifdef FURI_HAL_CRYPTO_ADVANCED_AVAIL - bool ret = (furi_hal_crypto_gcm_decrypt_and_verify(ctx->key, - msg->iv, - (uint8_t *) msg, RUN_ID_BYTES + COUNTER_BYTES, - msg->data, out, - in_len - MSG_OVERHEAD, - msg->tag) == FuriHalCryptoGCMStateOk); + bool ret = + (furi_hal_crypto_gcm_decrypt_and_verify( + ctx->key, + msg->iv, + (uint8_t*)msg, + RUN_ID_BYTES + COUNTER_BYTES, + msg->data, + out, + in_len - MSG_OVERHEAD, + msg->tag) == FuriHalCryptoGCMStateOk); #else /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - bool ret = (gcm_auth_decrypt(&(ctx->gcm_ctx), - msg->iv, IV_BYTES, - (uint8_t *) msg, RUN_ID_BYTES + COUNTER_BYTES, - msg->data, out, - in_len - MSG_OVERHEAD, - msg->tag, TAG_BYTES) == 0); + bool ret = + (gcm_auth_decrypt( + &(ctx->gcm_ctx), + msg->iv, + IV_BYTES, + (uint8_t*)msg, + RUN_ID_BYTES + COUNTER_BYTES, + msg->data, + out, + in_len - MSG_OVERHEAD, + msg->tag, + TAG_BYTES) == 0); #endif /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - // if auth was successful update replay dict - if (ret) { - ESubGhzChatReplayDict_set_at(ctx->replay_dict, msg->run_id, - __ntohl(msg->counter)); - } + // if auth was successful update replay dict + if(ret) { + ESubGhzChatReplayDict_set_at(ctx->replay_dict, msg->run_id, __ntohl(msg->counter)); + } - return ret; + return ret; } -bool crypto_ctx_encrypt(ESubGhzChatCryptoCtx *ctx, uint8_t *in, size_t in_len, - uint8_t *out) -{ - struct ESubGhzChatCryptoMsg *msg = (struct ESubGhzChatCryptoMsg *) out; +bool crypto_ctx_encrypt(ESubGhzChatCryptoCtx* ctx, uint8_t* in, size_t in_len, uint8_t* out) { + struct ESubGhzChatCryptoMsg* msg = (struct ESubGhzChatCryptoMsg*)out; - // fill message header - msg->run_id = ctx->run_id; - msg->counter = __htonl(ctx->counter); - furi_hal_random_fill_buf(msg->iv, IV_BYTES); + // fill message header + msg->run_id = ctx->run_id; + msg->counter = __htonl(ctx->counter); + furi_hal_random_fill_buf(msg->iv, IV_BYTES); - // encrypt message and store tag in header + // encrypt message and store tag in header #ifdef FURI_HAL_CRYPTO_ADVANCED_AVAIL - bool ret = (furi_hal_crypto_gcm_encrypt_and_tag(ctx->key, - msg->iv, - (uint8_t *) msg, RUN_ID_BYTES + COUNTER_BYTES, - in, msg->data, - in_len, - msg->tag) == FuriHalCryptoGCMStateOk); + bool ret = + (furi_hal_crypto_gcm_encrypt_and_tag( + ctx->key, + msg->iv, + (uint8_t*)msg, + RUN_ID_BYTES + COUNTER_BYTES, + in, + msg->data, + in_len, + msg->tag) == FuriHalCryptoGCMStateOk); #else /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - bool ret = (gcm_crypt_and_tag(&(ctx->gcm_ctx), ENCRYPT, - msg->iv, IV_BYTES, - (uint8_t *) msg, RUN_ID_BYTES + COUNTER_BYTES, - in, msg->data, - in_len, - msg->tag, TAG_BYTES) == 0); + bool ret = + (gcm_crypt_and_tag( + &(ctx->gcm_ctx), + ENCRYPT, + msg->iv, + IV_BYTES, + (uint8_t*)msg, + RUN_ID_BYTES + COUNTER_BYTES, + in, + msg->data, + in_len, + msg->tag, + TAG_BYTES) == 0); #endif /* FURI_HAL_CRYPTO_ADVANCED_AVAIL */ - // increase internal counter - if (ret) { - ctx->counter++; - } + // increase internal counter + if(ret) { + ctx->counter++; + } - return ret; + return ret; } diff --git a/applications/external/esubghz_chat/crypto_wrapper.h b/applications/external/esubghz_chat/crypto_wrapper.h index cfa992e75..4a3dcf8e5 100644 --- a/applications/external/esubghz_chat/crypto_wrapper.h +++ b/applications/external/esubghz_chat/crypto_wrapper.h @@ -17,21 +17,22 @@ typedef struct ESugGhzChatCryptoCtx ESubGhzChatCryptoCtx; void crypto_init(void); /* Function to clear sensitive memory. */ -void crypto_explicit_bzero(void *s, size_t len); +void crypto_explicit_bzero(void* s, size_t len); -ESubGhzChatCryptoCtx *crypto_ctx_alloc(void); -void crypto_ctx_free(ESubGhzChatCryptoCtx *ctx); +ESubGhzChatCryptoCtx* crypto_ctx_alloc(void); +void crypto_ctx_free(ESubGhzChatCryptoCtx* ctx); -void crypto_ctx_clear(ESubGhzChatCryptoCtx *ctx); +void crypto_ctx_clear(ESubGhzChatCryptoCtx* ctx); -bool crypto_ctx_set_key(ESubGhzChatCryptoCtx *ctx, const uint8_t *key, - FuriString *flipper_name, uint32_t tick); -void crypto_ctx_get_key(ESubGhzChatCryptoCtx *ctx, uint8_t *key); +bool crypto_ctx_set_key( + ESubGhzChatCryptoCtx* ctx, + const uint8_t* key, + FuriString* flipper_name, + uint32_t tick); +void crypto_ctx_get_key(ESubGhzChatCryptoCtx* ctx, uint8_t* key); -bool crypto_ctx_decrypt(ESubGhzChatCryptoCtx *ctx, uint8_t *in, size_t in_len, - uint8_t *out); -bool crypto_ctx_encrypt(ESubGhzChatCryptoCtx *ctx, uint8_t *in, size_t in_len, - uint8_t *out); +bool crypto_ctx_decrypt(ESubGhzChatCryptoCtx* ctx, uint8_t* in, size_t in_len, uint8_t* out); +bool crypto_ctx_encrypt(ESubGhzChatCryptoCtx* ctx, uint8_t* in, size_t in_len, uint8_t* out); #ifdef __cplusplus } diff --git a/applications/external/esubghz_chat/esubghz_chat.c b/applications/external/esubghz_chat/esubghz_chat.c index 0c0bd5c1f..342f244ed 100644 --- a/applications/external/esubghz_chat/esubghz_chat.c +++ b/applications/external/esubghz_chat/esubghz_chat.c @@ -15,723 +15,672 @@ /* Callback for RX events from the Sub-GHz worker. Records the current ticks as * the time of the last reception. */ -static void have_read_cb(void* context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static void have_read_cb(void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - state->last_time_rx_data = furi_get_tick(); + state->last_time_rx_data = furi_get_tick(); } /* Sets the header for the chat input field depending on whether or not a * message preview exists. */ -void set_chat_input_header(ESubGhzChatState *state) -{ - if (strlen(state->msg_preview) == 0) { - text_input_set_header_text(state->text_input, "Message"); - } else { - text_input_set_header_text(state->text_input, - state->msg_preview); - } +void set_chat_input_header(ESubGhzChatState* state) { + if(strlen(state->msg_preview) == 0) { + text_input_set_header_text(state->text_input, "Message"); + } else { + text_input_set_header_text(state->text_input, state->msg_preview); + } } /* Appends the latest message to the chat box and prepares the message preview. */ -void append_msg(ESubGhzChatState *state, const char *msg) -{ - /* append message to text box */ - furi_string_cat_printf(state->chat_box_store, "\n%s", msg); +void append_msg(ESubGhzChatState* state, const char* msg) { + /* append message to text box */ + furi_string_cat_printf(state->chat_box_store, "\n%s", msg); - /* prepare message preview */ - strncpy(state->msg_preview, msg, MSG_PREVIEW_SIZE); - state->msg_preview[MSG_PREVIEW_SIZE] = 0; - set_chat_input_header(state); + /* prepare message preview */ + strncpy(state->msg_preview, msg, MSG_PREVIEW_SIZE); + state->msg_preview[MSG_PREVIEW_SIZE] = 0; + set_chat_input_header(state); - /* reset text box contents and focus */ - text_box_set_text(state->chat_box, - furi_string_get_cstr(state->chat_box_store)); - text_box_set_focus(state->chat_box, TextBoxFocusEnd); + /* reset text box contents and focus */ + text_box_set_text(state->chat_box, furi_string_get_cstr(state->chat_box_store)); + text_box_set_focus(state->chat_box, TextBoxFocusEnd); } /* Decrypts a message for post_rx(). */ -static bool post_rx_decrypt(ESubGhzChatState *state, size_t rx_size) -{ - bool ret = crypto_ctx_decrypt(state->crypto_ctx, - state->rx_buffer, rx_size, - (uint8_t*) state->rx_str_buffer); +static bool post_rx_decrypt(ESubGhzChatState* state, size_t rx_size) { + bool ret = crypto_ctx_decrypt( + state->crypto_ctx, state->rx_buffer, rx_size, (uint8_t*)state->rx_str_buffer); - if (ret) { - state->rx_str_buffer[rx_size - (MSG_OVERHEAD)] = 0; - } else { - state->rx_str_buffer[0] = 0; - } + if(ret) { + state->rx_str_buffer[rx_size - (MSG_OVERHEAD)] = 0; + } else { + state->rx_str_buffer[0] = 0; + } - return ret; + return ret; } /* Post RX handler, decrypts received messages and calls append_msg(). */ -static void post_rx(ESubGhzChatState *state, size_t rx_size) -{ - furi_assert(state); +static void post_rx(ESubGhzChatState* state, size_t rx_size) { + furi_assert(state); - if (rx_size == 0) { - return; - } + if(rx_size == 0) { + return; + } - furi_check(rx_size <= RX_TX_BUFFER_SIZE); + furi_check(rx_size <= RX_TX_BUFFER_SIZE); - /* decrypt if necessary */ - if (!state->encrypted) { - memcpy(state->rx_str_buffer, state->rx_buffer, rx_size); - state->rx_str_buffer[rx_size] = 0; + /* decrypt if necessary */ + if(!state->encrypted) { + memcpy(state->rx_str_buffer, state->rx_buffer, rx_size); + state->rx_str_buffer[rx_size] = 0; - /* remove trailing newline if it is there, for compat with CLI + /* remove trailing newline if it is there, for compat with CLI * Sub-GHz chat */ - if (state->rx_str_buffer[rx_size - 1] == '\n') { - state->rx_str_buffer[rx_size - 1] = 0; - } - } else { - /* if decryption fails output an error message */ - if (!post_rx_decrypt(state, rx_size)) { - strcpy(state->rx_str_buffer, "ERR: Decryption failed!"); - } - } + if(state->rx_str_buffer[rx_size - 1] == '\n') { + state->rx_str_buffer[rx_size - 1] = 0; + } + } else { + /* if decryption fails output an error message */ + if(!post_rx_decrypt(state, rx_size)) { + strcpy(state->rx_str_buffer, "ERR: Decryption failed!"); + } + } - /* append message to text box and prepare message preview */ - append_msg(state, state->rx_str_buffer); + /* append message to text box and prepare message preview */ + append_msg(state, state->rx_str_buffer); - /* send notification (make the flipper vibrate) */ - notification_message(state->notification, &sequence_single_vibro); + /* send notification (make the flipper vibrate) */ + notification_message(state->notification, &sequence_single_vibro); } /* Reads the message from msg_input, encrypts it if necessary and then * transmits it. */ -void tx_msg_input(ESubGhzChatState *state) -{ - /* encrypt message if necessary */ - size_t msg_len = strlen(furi_string_get_cstr(state->msg_input)); - size_t tx_size = msg_len; - if (state->encrypted) { - tx_size += MSG_OVERHEAD; - furi_check(tx_size <= sizeof(state->tx_buffer)); +void tx_msg_input(ESubGhzChatState* state) { + /* encrypt message if necessary */ + size_t msg_len = strlen(furi_string_get_cstr(state->msg_input)); + size_t tx_size = msg_len; + if(state->encrypted) { + tx_size += MSG_OVERHEAD; + furi_check(tx_size <= sizeof(state->tx_buffer)); - crypto_ctx_encrypt(state->crypto_ctx, - (uint8_t *) - furi_string_get_cstr(state->msg_input), - msg_len, - state->tx_buffer); - } else { - tx_size += 2; - furi_check(tx_size <= sizeof(state->tx_buffer)); - memcpy(state->tx_buffer, - furi_string_get_cstr(state->msg_input), - msg_len); + crypto_ctx_encrypt( + state->crypto_ctx, + (uint8_t*)furi_string_get_cstr(state->msg_input), + msg_len, + state->tx_buffer); + } else { + tx_size += 2; + furi_check(tx_size <= sizeof(state->tx_buffer)); + memcpy(state->tx_buffer, furi_string_get_cstr(state->msg_input), msg_len); - /* append \r\n for compat with Sub-GHz CLI chat */ - state->tx_buffer[msg_len] = '\r'; - state->tx_buffer[msg_len + 1] = '\n'; - } + /* append \r\n for compat with Sub-GHz CLI chat */ + state->tx_buffer[msg_len] = '\r'; + state->tx_buffer[msg_len + 1] = '\n'; + } - /* transmit */ - subghz_tx_rx_worker_write(state->subghz_worker, state->tx_buffer, - tx_size); + /* transmit */ + subghz_tx_rx_worker_write(state->subghz_worker, state->tx_buffer, tx_size); } /* Displays whether or not encryption has been enabled in the text box. Also * clears the text input buffer to remove the password and starts the Sub-GHz * worker. After starting the worker a join message is transmitted. */ -void enter_chat(ESubGhzChatState *state) -{ - furi_string_cat_printf(state->chat_box_store, "\nEncrypted: %s", - (state->encrypted ? "yes" : "no")); +void enter_chat(ESubGhzChatState* state) { + furi_string_cat_printf( + state->chat_box_store, "\nEncrypted: %s", (state->encrypted ? "yes" : "no")); - subghz_tx_rx_worker_start(state->subghz_worker, state->subghz_device, - state->frequency); + subghz_tx_rx_worker_start(state->subghz_worker, state->subghz_device, state->frequency); - /* concatenate the name prefix and join message */ - furi_string_set(state->msg_input, state->name_prefix); - furi_string_cat_str(state->msg_input, " joined chat."); + /* concatenate the name prefix and join message */ + furi_string_set(state->msg_input, state->name_prefix); + furi_string_cat_str(state->msg_input, " joined chat."); - /* encrypt and transmit message */ - tx_msg_input(state); + /* encrypt and transmit message */ + tx_msg_input(state); - /* clear message input buffer */ - furi_string_set_char(state->msg_input, 0, 0); + /* clear message input buffer */ + furi_string_set_char(state->msg_input, 0, 0); } /* Sends a leave message */ -void exit_chat(ESubGhzChatState *state) -{ - /* concatenate the name prefix and leave message */ - furi_string_set(state->msg_input, state->name_prefix); - furi_string_cat_str(state->msg_input, " left chat."); +void exit_chat(ESubGhzChatState* state) { + /* concatenate the name prefix and leave message */ + furi_string_set(state->msg_input, state->name_prefix); + furi_string_cat_str(state->msg_input, " left chat."); - /* encrypt and transmit message */ - tx_msg_input(state); + /* encrypt and transmit message */ + tx_msg_input(state); - /* clear message input buffer */ - furi_string_set_char(state->msg_input, 0, 0); + /* clear message input buffer */ + furi_string_set_char(state->msg_input, 0, 0); - /* wait for leave message to be delivered */ - furi_delay_ms(CHAT_LEAVE_DELAY); + /* wait for leave message to be delivered */ + furi_delay_ms(CHAT_LEAVE_DELAY); } /* Whether or not to display the locked message. */ -static bool kbd_lock_msg_display(ESubGhzChatState *state) -{ - return (state->kbd_lock_msg_ticks != 0); +static bool kbd_lock_msg_display(ESubGhzChatState* state) { + return (state->kbd_lock_msg_ticks != 0); } /* Whether or not to hide the locked message again. */ -static bool kbd_lock_msg_reset_timeout(ESubGhzChatState *state) -{ - if (state->kbd_lock_msg_ticks == 0) { - return false; - } +static bool kbd_lock_msg_reset_timeout(ESubGhzChatState* state) { + if(state->kbd_lock_msg_ticks == 0) { + return false; + } - if (furi_get_tick() - state->kbd_lock_msg_ticks > KBD_UNLOCK_TIMEOUT) { - return true; - } + if(furi_get_tick() - state->kbd_lock_msg_ticks > KBD_UNLOCK_TIMEOUT) { + return true; + } - return false; + return false; } /* Resets the timeout for the locked message and turns off the backlight if * specified. */ -static void kbd_lock_msg_reset(ESubGhzChatState *state, bool backlight_off) -{ - state->kbd_lock_msg_ticks = 0; - state->kbd_lock_count = 0; +static void kbd_lock_msg_reset(ESubGhzChatState* state, bool backlight_off) { + state->kbd_lock_msg_ticks = 0; + state->kbd_lock_count = 0; - if (backlight_off) { - notification_message(state->notification, - &sequence_display_backlight_off); - } + if(backlight_off) { + notification_message(state->notification, &sequence_display_backlight_off); + } } /* Locks the keyboard. */ -static void kbd_lock(ESubGhzChatState *state) -{ - state->kbd_locked = true; - kbd_lock_msg_reset(state, true); +static void kbd_lock(ESubGhzChatState* state) { + state->kbd_locked = true; + kbd_lock_msg_reset(state, true); } /* Unlocks the keyboard. */ -static void kbd_unlock(ESubGhzChatState *state) -{ - state->kbd_locked = false; - kbd_lock_msg_reset(state, false); +static void kbd_unlock(ESubGhzChatState* state) { + state->kbd_locked = false; + kbd_lock_msg_reset(state, false); } /* Custom event callback for view dispatcher. Just calls scene manager. */ -static bool esubghz_chat_custom_event_callback(void* context, uint32_t event) -{ - FURI_LOG_T(APPLICATION_NAME, "esubghz_chat_custom_event_callback"); - furi_assert(context); - ESubGhzChatState* state = context; - return scene_manager_handle_custom_event(state->scene_manager, event); +static bool esubghz_chat_custom_event_callback(void* context, uint32_t event) { + FURI_LOG_T(APPLICATION_NAME, "esubghz_chat_custom_event_callback"); + furi_assert(context); + ESubGhzChatState* state = context; + return scene_manager_handle_custom_event(state->scene_manager, event); } /* Navigation event callback for view dispatcher. Just calls scene manager. */ -static bool esubghz_chat_navigation_event_callback(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "esubghz_chat_navigation_event_callback"); - furi_assert(context); - ESubGhzChatState* state = context; - return scene_manager_handle_back_event(state->scene_manager); +static bool esubghz_chat_navigation_event_callback(void* context) { + FURI_LOG_T(APPLICATION_NAME, "esubghz_chat_navigation_event_callback"); + furi_assert(context); + ESubGhzChatState* state = context; + return scene_manager_handle_back_event(state->scene_manager); } /* Tick event callback for view dispatcher. Called every TICK_INTERVAL. Resets * the locked message if necessary. Retrieves a received message from the * Sub-GHz worker and calls post_rx(). Then calls the scene manager. */ -static void esubghz_chat_tick_event_callback(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "esubghz_chat_tick_event_callback"); +static void esubghz_chat_tick_event_callback(void* context) { + FURI_LOG_T(APPLICATION_NAME, "esubghz_chat_tick_event_callback"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - /* reset locked message if necessary */ - if (kbd_lock_msg_reset_timeout(state)) { - kbd_lock_msg_reset(state, true); - } + /* reset locked message if necessary */ + if(kbd_lock_msg_reset_timeout(state)) { + kbd_lock_msg_reset(state, true); + } - /* if the maximum message size was reached or the + /* if the maximum message size was reached or the * MESSAGE_COMPLETION_TIMEOUT has expired, retrieve a message and call * post_rx() */ - size_t avail = 0; - while ((avail = subghz_tx_rx_worker_available(state->subghz_worker)) > - 0) { - volatile uint32_t since_last_rx = furi_get_tick() - - state->last_time_rx_data; - if (avail < RX_TX_BUFFER_SIZE && since_last_rx < - MESSAGE_COMPLETION_TIMEOUT) { - break; - } + size_t avail = 0; + while((avail = subghz_tx_rx_worker_available(state->subghz_worker)) > 0) { + volatile uint32_t since_last_rx = furi_get_tick() - state->last_time_rx_data; + if(avail < RX_TX_BUFFER_SIZE && since_last_rx < MESSAGE_COMPLETION_TIMEOUT) { + break; + } - size_t rx_size = subghz_tx_rx_worker_read(state->subghz_worker, - state->rx_buffer, RX_TX_BUFFER_SIZE); - post_rx(state, rx_size); - } + size_t rx_size = + subghz_tx_rx_worker_read(state->subghz_worker, state->rx_buffer, RX_TX_BUFFER_SIZE); + post_rx(state, rx_size); + } - /* call scene manager */ - scene_manager_handle_tick_event(state->scene_manager); + /* call scene manager */ + scene_manager_handle_tick_event(state->scene_manager); } /* Hooks into the view port's draw callback to overlay the keyboard locked * message. */ -static void esubghz_hooked_draw_callback(Canvas* canvas, void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "esubghz_hooked_draw_callback"); +static void esubghz_hooked_draw_callback(Canvas* canvas, void* context) { + FURI_LOG_T(APPLICATION_NAME, "esubghz_hooked_draw_callback"); - furi_assert(canvas); + furi_assert(canvas); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - /* call original callback */ - state->orig_draw_cb(canvas, state->view_dispatcher); + /* call original callback */ + state->orig_draw_cb(canvas, state->view_dispatcher); - /* display if the keyboard is locked */ - if (state->kbd_locked) { - canvas_set_font(canvas, FontPrimary); - elements_multiline_text_framed(canvas, 42, 30, "Locked"); - } + /* display if the keyboard is locked */ + if(state->kbd_locked) { + canvas_set_font(canvas, FontPrimary); + elements_multiline_text_framed(canvas, 42, 30, "Locked"); + } - /* display the unlock message if necessary */ - if (kbd_lock_msg_display(state)) { - canvas_set_font(canvas, FontSecondary); - elements_bold_rounded_frame(canvas, 14, 8, 99, 48); - elements_multiline_text(canvas, 65, 26, "To unlock\npress:"); - canvas_draw_icon(canvas, 65, 42, &I_Pin_back_arrow_10x8); - canvas_draw_icon(canvas, 80, 42, &I_Pin_back_arrow_10x8); - canvas_draw_icon(canvas, 95, 42, &I_Pin_back_arrow_10x8); - canvas_draw_icon(canvas, 16, 13, &I_WarningDolphin_45x42); - } + /* display the unlock message if necessary */ + if(kbd_lock_msg_display(state)) { + canvas_set_font(canvas, FontSecondary); + elements_bold_rounded_frame(canvas, 14, 8, 99, 48); + elements_multiline_text(canvas, 65, 26, "To unlock\npress:"); + canvas_draw_icon(canvas, 65, 42, &I_Pin_back_arrow_10x8); + canvas_draw_icon(canvas, 80, 42, &I_Pin_back_arrow_10x8); + canvas_draw_icon(canvas, 95, 42, &I_Pin_back_arrow_10x8); + canvas_draw_icon(canvas, 16, 13, &I_WarningDolphin_45x42); + } } /* Hooks into the view port's input callback to handle the user locking the * keyboard. */ -static void esubghz_hooked_input_callback(InputEvent* event, void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "esubghz_hooked_input_callback"); +static void esubghz_hooked_input_callback(InputEvent* event, void* context) { + FURI_LOG_T(APPLICATION_NAME, "esubghz_hooked_input_callback"); - furi_assert(event); + furi_assert(event); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - /* if the keyboard is locked no key presses are forwarded */ - if (state->kbd_locked) { - /* key has been pressed, display the unlock message and + /* if the keyboard is locked no key presses are forwarded */ + if(state->kbd_locked) { + /* key has been pressed, display the unlock message and * initiate the timer */ - if (state->kbd_lock_count == 0) { - state->kbd_lock_msg_ticks = furi_get_tick(); - } + if(state->kbd_lock_count == 0) { + state->kbd_lock_msg_ticks = furi_get_tick(); + } - /* back button has been pressed, increase the lock counter */ - if (event->key == InputKeyBack && event->type == - InputTypeShort) { - state->kbd_lock_count++; - } + /* back button has been pressed, increase the lock counter */ + if(event->key == InputKeyBack && event->type == InputTypeShort) { + state->kbd_lock_count++; + } - /* unlock the keyboard */ - if (state->kbd_lock_count >= KBD_UNLOCK_CNT) { - kbd_unlock(state); - } + /* unlock the keyboard */ + if(state->kbd_lock_count >= KBD_UNLOCK_CNT) { + kbd_unlock(state); + } - /* do not handle the event */ - return; - } + /* do not handle the event */ + return; + } - if (event->key == InputKeyOk) { - /* if we are in the chat view and no input is ongoing, allow + if(event->key == InputKeyOk) { + /* if we are in the chat view and no input is ongoing, allow * locking */ - if (state->view_dispatcher->current_view == - text_box_get_view(state->chat_box) && - !(state->kbd_ok_input_ongoing)) { - /* lock keyboard upon long press of Ok button */ - if (event->type == InputTypeLong) { - kbd_lock(state); - } + if(state->view_dispatcher->current_view == text_box_get_view(state->chat_box) && + !(state->kbd_ok_input_ongoing)) { + /* lock keyboard upon long press of Ok button */ + if(event->type == InputTypeLong) { + kbd_lock(state); + } - /* do not handle any Ok key events to prevent blocking + /* do not handle any Ok key events to prevent blocking * of other keys */ - return; - } + return; + } - /* handle ongoing inputs when changing to chat view */ - if (event->type == InputTypePress) { - state->kbd_ok_input_ongoing = true; - } else if (event->type == InputTypeRelease) { - state->kbd_ok_input_ongoing = false; - } - } + /* handle ongoing inputs when changing to chat view */ + if(event->type == InputTypePress) { + state->kbd_ok_input_ongoing = true; + } else if(event->type == InputTypeRelease) { + state->kbd_ok_input_ongoing = false; + } + } - if (event->key == InputKeyLeft) { - /* if we are in the chat view and no input is ongoing, allow + if(event->key == InputKeyLeft) { + /* if we are in the chat view and no input is ongoing, allow * switching to msg input */ - if (state->view_dispatcher->current_view == - text_box_get_view(state->chat_box) && - !(state->kbd_left_input_ongoing)) { - /* go to msg input upon short press of Left button */ - if (event->type == InputTypeShort) { - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_GotoMsgInput); - } + if(state->view_dispatcher->current_view == text_box_get_view(state->chat_box) && + !(state->kbd_left_input_ongoing)) { + /* go to msg input upon short press of Left button */ + if(event->type == InputTypeShort) { + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_GotoMsgInput); + } - /* do not handle any Left key events to prevent + /* do not handle any Left key events to prevent * blocking of other keys */ - return; - } + return; + } - /* handle ongoing inputs when changing to chat view */ - if (event->type == InputTypePress) { - state->kbd_left_input_ongoing = true; - } else if (event->type == InputTypeRelease) { - state->kbd_left_input_ongoing = false; - } - } + /* handle ongoing inputs when changing to chat view */ + if(event->type == InputTypePress) { + state->kbd_left_input_ongoing = true; + } else if(event->type == InputTypeRelease) { + state->kbd_left_input_ongoing = false; + } + } - if (event->key == InputKeyRight) { - /* if we are in the chat view and no input is ongoing, allow + if(event->key == InputKeyRight) { + /* if we are in the chat view and no input is ongoing, allow * switching to key display */ - if (state->view_dispatcher->current_view == - text_box_get_view(state->chat_box) && - !(state->kbd_right_input_ongoing)) { - /* go to key display upon short press of Right button + if(state->view_dispatcher->current_view == text_box_get_view(state->chat_box) && + !(state->kbd_right_input_ongoing)) { + /* go to key display upon short press of Right button */ - if (event->type == InputTypeShort) { - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_GotoKeyDisplay); - } + if(event->type == InputTypeShort) { + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_GotoKeyDisplay); + } - /* do not handle any Right key events to prevent + /* do not handle any Right key events to prevent * blocking of other keys */ - return; - } + return; + } - /* handle ongoing inputs when changing to chat view */ - if (event->type == InputTypePress) { - state->kbd_right_input_ongoing = true; - } else if (event->type == InputTypeRelease) { - state->kbd_right_input_ongoing = false; - } - } + /* handle ongoing inputs when changing to chat view */ + if(event->type == InputTypePress) { + state->kbd_right_input_ongoing = true; + } else if(event->type == InputTypeRelease) { + state->kbd_right_input_ongoing = false; + } + } - /* call original callback */ - state->orig_input_cb(event, state->view_dispatcher); + /* call original callback */ + state->orig_input_cb(event, state->view_dispatcher); } -static bool helper_strings_alloc(ESubGhzChatState *state) -{ - furi_assert(state); +static bool helper_strings_alloc(ESubGhzChatState* state) { + furi_assert(state); - state->name_prefix = furi_string_alloc(); - if (state->name_prefix == NULL) { - return false; - } + state->name_prefix = furi_string_alloc(); + if(state->name_prefix == NULL) { + return false; + } - state->msg_input = furi_string_alloc(); - if (state->msg_input == NULL) { - furi_string_free(state->name_prefix); - return false; - } + state->msg_input = furi_string_alloc(); + if(state->msg_input == NULL) { + furi_string_free(state->name_prefix); + return false; + } - return true; + return true; } -static void helper_strings_free(ESubGhzChatState *state) -{ - furi_assert(state); +static void helper_strings_free(ESubGhzChatState* state) { + furi_assert(state); - furi_string_free(state->name_prefix); - furi_string_free(state->msg_input); + furi_string_free(state->name_prefix); + furi_string_free(state->msg_input); } -static bool chat_box_alloc(ESubGhzChatState *state) -{ - furi_assert(state); +static bool chat_box_alloc(ESubGhzChatState* state) { + furi_assert(state); - state->chat_box = text_box_alloc(); - if (state->chat_box == NULL) { - return false; - } + state->chat_box = text_box_alloc(); + if(state->chat_box == NULL) { + return false; + } - state->chat_box_store = furi_string_alloc(); - if (state->chat_box_store == NULL) { - text_box_free(state->chat_box); - return false; - } + state->chat_box_store = furi_string_alloc(); + if(state->chat_box_store == NULL) { + text_box_free(state->chat_box); + return false; + } - furi_string_reserve(state->chat_box_store, CHAT_BOX_STORE_SIZE); - furi_string_set_char(state->chat_box_store, 0, 0); - text_box_set_text(state->chat_box, - furi_string_get_cstr(state->chat_box_store)); - text_box_set_focus(state->chat_box, TextBoxFocusEnd); + furi_string_reserve(state->chat_box_store, CHAT_BOX_STORE_SIZE); + furi_string_set_char(state->chat_box_store, 0, 0); + text_box_set_text(state->chat_box, furi_string_get_cstr(state->chat_box_store)); + text_box_set_focus(state->chat_box, TextBoxFocusEnd); - return true; + return true; } -static void chat_box_free(ESubGhzChatState *state) -{ - furi_assert(state); +static void chat_box_free(ESubGhzChatState* state) { + furi_assert(state); - text_box_free(state->chat_box); - furi_string_free(state->chat_box_store); + text_box_free(state->chat_box); + furi_string_free(state->chat_box_store); } -int32_t esubghz_chat(void) -{ - /* init the crypto system */ - crypto_init(); +int32_t esubghz_chat(void) { + /* init the crypto system */ + crypto_init(); - int32_t err = -1; + int32_t err = -1; - FURI_LOG_I(APPLICATION_NAME, "Starting..."); + FURI_LOG_I(APPLICATION_NAME, "Starting..."); - /* allocate necessary structs and buffers */ + /* allocate necessary structs and buffers */ - ESubGhzChatState *state = malloc(sizeof(ESubGhzChatState)); - if (state == NULL) { - goto err_alloc; - } - memset(state, 0, sizeof(*state)); + ESubGhzChatState* state = malloc(sizeof(ESubGhzChatState)); + if(state == NULL) { + goto err_alloc; + } + memset(state, 0, sizeof(*state)); - state->scene_manager = scene_manager_alloc( - &esubghz_chat_scene_event_handlers, state); - if (state->scene_manager == NULL) { - goto err_alloc_sm; - } + state->scene_manager = scene_manager_alloc(&esubghz_chat_scene_event_handlers, state); + if(state->scene_manager == NULL) { + goto err_alloc_sm; + } - state->view_dispatcher = view_dispatcher_alloc(); - if (state->view_dispatcher == NULL) { - goto err_alloc_vd; - } + state->view_dispatcher = view_dispatcher_alloc(); + if(state->view_dispatcher == NULL) { + goto err_alloc_vd; + } - if (!helper_strings_alloc(state)) { - goto err_alloc_hs; - } + if(!helper_strings_alloc(state)) { + goto err_alloc_hs; + } - state->menu = menu_alloc(); - if (state->menu == NULL) { - goto err_alloc_menu; - } + state->menu = menu_alloc(); + if(state->menu == NULL) { + goto err_alloc_menu; + } - state->text_input = text_input_alloc(); - if (state->text_input == NULL) { - goto err_alloc_ti; - } + state->text_input = text_input_alloc(); + if(state->text_input == NULL) { + goto err_alloc_ti; + } - state->hex_key_input = byte_input_alloc(); - if (state->hex_key_input == NULL) { - goto err_alloc_hki; - } + state->hex_key_input = byte_input_alloc(); + if(state->hex_key_input == NULL) { + goto err_alloc_hki; + } - if (!chat_box_alloc(state)) { - goto err_alloc_cb; - } + if(!chat_box_alloc(state)) { + goto err_alloc_cb; + } - state->key_display = dialog_ex_alloc(); - if (state->key_display == NULL) { - goto err_alloc_kd; - } + state->key_display = dialog_ex_alloc(); + if(state->key_display == NULL) { + goto err_alloc_kd; + } - state->nfc_popup = popup_alloc(); - if (state->nfc_popup == NULL) { - goto err_alloc_np; - } + state->nfc_popup = popup_alloc(); + if(state->nfc_popup == NULL) { + goto err_alloc_np; + } - state->subghz_worker = subghz_tx_rx_worker_alloc(); - if (state->subghz_worker == NULL) { - goto err_alloc_worker; - } + state->subghz_worker = subghz_tx_rx_worker_alloc(); + if(state->subghz_worker == NULL) { + goto err_alloc_worker; + } - state->nfc_worker = nfc_worker_alloc(); - if (state->nfc_worker == NULL) { - goto err_alloc_nworker; - } + state->nfc_worker = nfc_worker_alloc(); + if(state->nfc_worker == NULL) { + goto err_alloc_nworker; + } - state->nfc_dev_data = malloc(sizeof(NfcDeviceData)); - if (state->nfc_dev_data == NULL) { - goto err_alloc_ndevdata; - } - memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData)); + state->nfc_dev_data = malloc(sizeof(NfcDeviceData)); + if(state->nfc_dev_data == NULL) { + goto err_alloc_ndevdata; + } + memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData)); - state->crypto_ctx = crypto_ctx_alloc(); - if (state->crypto_ctx == NULL) { - goto err_alloc_crypto; - } + state->crypto_ctx = crypto_ctx_alloc(); + if(state->crypto_ctx == NULL) { + goto err_alloc_crypto; + } - /* set the have_read callback of the Sub-GHz worker */ - subghz_tx_rx_worker_set_callback_have_read(state->subghz_worker, - have_read_cb, state); + /* set the have_read callback of the Sub-GHz worker */ + subghz_tx_rx_worker_set_callback_have_read(state->subghz_worker, have_read_cb, state); - /* enter suppress charge mode */ - furi_hal_power_suppress_charge_enter(); + /* enter suppress charge mode */ + furi_hal_power_suppress_charge_enter(); - /* init internal device */ - subghz_devices_init(); - state->subghz_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME); + /* init internal device */ + subghz_devices_init(); + state->subghz_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME); - /* set chat name prefix */ - furi_string_printf(state->name_prefix, "%s", - furi_hal_version_get_name_ptr()); + /* set chat name prefix */ + furi_string_printf(state->name_prefix, "%s", furi_hal_version_get_name_ptr()); - /* get notification record, we use this to make the flipper vibrate */ - /* no error handling here, don't know how */ - state->notification = furi_record_open(RECORD_NOTIFICATION); + /* get notification record, we use this to make the flipper vibrate */ + /* no error handling here, don't know how */ + state->notification = furi_record_open(RECORD_NOTIFICATION); - /* hook into the view port's draw and input callbacks */ - state->orig_draw_cb = state->view_dispatcher->view_port->draw_callback; - state->orig_input_cb = state->view_dispatcher->view_port->input_callback; - view_port_draw_callback_set(state->view_dispatcher->view_port, - esubghz_hooked_draw_callback, state); - view_port_input_callback_set(state->view_dispatcher->view_port, - esubghz_hooked_input_callback, state); + /* hook into the view port's draw and input callbacks */ + state->orig_draw_cb = state->view_dispatcher->view_port->draw_callback; + state->orig_input_cb = state->view_dispatcher->view_port->input_callback; + view_port_draw_callback_set( + state->view_dispatcher->view_port, esubghz_hooked_draw_callback, state); + view_port_input_callback_set( + state->view_dispatcher->view_port, esubghz_hooked_input_callback, state); - view_dispatcher_enable_queue(state->view_dispatcher); + view_dispatcher_enable_queue(state->view_dispatcher); - /* set callbacks for view dispatcher */ - view_dispatcher_set_event_callback_context(state->view_dispatcher, state); - view_dispatcher_set_custom_event_callback( - state->view_dispatcher, - esubghz_chat_custom_event_callback); - view_dispatcher_set_navigation_event_callback( - state->view_dispatcher, - esubghz_chat_navigation_event_callback); - view_dispatcher_set_tick_event_callback( - state->view_dispatcher, - esubghz_chat_tick_event_callback, - TICK_INTERVAL); + /* set callbacks for view dispatcher */ + view_dispatcher_set_event_callback_context(state->view_dispatcher, state); + view_dispatcher_set_custom_event_callback( + state->view_dispatcher, esubghz_chat_custom_event_callback); + view_dispatcher_set_navigation_event_callback( + state->view_dispatcher, esubghz_chat_navigation_event_callback); + view_dispatcher_set_tick_event_callback( + state->view_dispatcher, esubghz_chat_tick_event_callback, TICK_INTERVAL); - /* add our two views to the view dispatcher */ - view_dispatcher_add_view(state->view_dispatcher, ESubGhzChatView_Menu, - menu_get_view(state->menu)); - view_dispatcher_add_view(state->view_dispatcher, ESubGhzChatView_Input, - text_input_get_view(state->text_input)); - view_dispatcher_add_view(state->view_dispatcher, ESubGhzChatView_HexKeyInput, - byte_input_get_view(state->hex_key_input)); - view_dispatcher_add_view(state->view_dispatcher, ESubGhzChatView_ChatBox, - text_box_get_view(state->chat_box)); - view_dispatcher_add_view(state->view_dispatcher, ESubGhzChatView_KeyDisplay, - dialog_ex_get_view(state->key_display)); - view_dispatcher_add_view(state->view_dispatcher, ESubGhzChatView_NfcPopup, - popup_get_view(state->nfc_popup)); + /* add our two views to the view dispatcher */ + view_dispatcher_add_view( + state->view_dispatcher, ESubGhzChatView_Menu, menu_get_view(state->menu)); + view_dispatcher_add_view( + state->view_dispatcher, ESubGhzChatView_Input, text_input_get_view(state->text_input)); + view_dispatcher_add_view( + state->view_dispatcher, + ESubGhzChatView_HexKeyInput, + byte_input_get_view(state->hex_key_input)); + view_dispatcher_add_view( + state->view_dispatcher, ESubGhzChatView_ChatBox, text_box_get_view(state->chat_box)); + view_dispatcher_add_view( + state->view_dispatcher, + ESubGhzChatView_KeyDisplay, + dialog_ex_get_view(state->key_display)); + view_dispatcher_add_view( + state->view_dispatcher, ESubGhzChatView_NfcPopup, popup_get_view(state->nfc_popup)); - /* get the GUI record and attach the view dispatcher to the GUI */ - /* no error handling here, don't know how */ - Gui *gui = furi_record_open(RECORD_GUI); - view_dispatcher_attach_to_gui(state->view_dispatcher, gui, - ViewDispatcherTypeFullscreen); + /* get the GUI record and attach the view dispatcher to the GUI */ + /* no error handling here, don't know how */ + Gui* gui = furi_record_open(RECORD_GUI); + view_dispatcher_attach_to_gui(state->view_dispatcher, gui, ViewDispatcherTypeFullscreen); - /* switch to the frequency input scene */ - scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_FreqInput); + /* switch to the frequency input scene */ + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_FreqInput); - /* run the view dispatcher, this call only returns when we close the + /* run the view dispatcher, this call only returns when we close the * application */ - view_dispatcher_run(state->view_dispatcher); + view_dispatcher_run(state->view_dispatcher); - /* if it is running, stop the Sub-GHz worker */ - if (subghz_tx_rx_worker_is_running(state->subghz_worker)) { - exit_chat(state); - subghz_tx_rx_worker_stop(state->subghz_worker); - } + /* if it is running, stop the Sub-GHz worker */ + if(subghz_tx_rx_worker_is_running(state->subghz_worker)) { + exit_chat(state); + subghz_tx_rx_worker_stop(state->subghz_worker); + } - /* if it is running, stop the NFC worker */ - nfc_worker_stop(state->nfc_worker); + /* if it is running, stop the NFC worker */ + nfc_worker_stop(state->nfc_worker); - err = 0; + err = 0; - /* close GUI record */ - furi_record_close(RECORD_GUI); + /* close GUI record */ + furi_record_close(RECORD_GUI); - /* remove our two views from the view dispatcher */ - view_dispatcher_remove_view(state->view_dispatcher, - ESubGhzChatView_Menu); - view_dispatcher_remove_view(state->view_dispatcher, - ESubGhzChatView_Input); - view_dispatcher_remove_view(state->view_dispatcher, - ESubGhzChatView_HexKeyInput); - view_dispatcher_remove_view(state->view_dispatcher, - ESubGhzChatView_ChatBox); - view_dispatcher_remove_view(state->view_dispatcher, - ESubGhzChatView_KeyDisplay); - view_dispatcher_remove_view(state->view_dispatcher, - ESubGhzChatView_NfcPopup); + /* remove our two views from the view dispatcher */ + view_dispatcher_remove_view(state->view_dispatcher, ESubGhzChatView_Menu); + view_dispatcher_remove_view(state->view_dispatcher, ESubGhzChatView_Input); + view_dispatcher_remove_view(state->view_dispatcher, ESubGhzChatView_HexKeyInput); + view_dispatcher_remove_view(state->view_dispatcher, ESubGhzChatView_ChatBox); + view_dispatcher_remove_view(state->view_dispatcher, ESubGhzChatView_KeyDisplay); + view_dispatcher_remove_view(state->view_dispatcher, ESubGhzChatView_NfcPopup); - /* close notification record */ - furi_record_close(RECORD_NOTIFICATION); + /* close notification record */ + furi_record_close(RECORD_NOTIFICATION); - /* clear the key and potential password */ - crypto_explicit_bzero(state->text_input_store, - sizeof(state->text_input_store)); - crypto_explicit_bzero(state->hex_key_input_store, - sizeof(state->hex_key_input_store)); - crypto_explicit_bzero(state->key_hex_str, sizeof(state->key_hex_str)); - crypto_ctx_clear(state->crypto_ctx); + /* clear the key and potential password */ + crypto_explicit_bzero(state->text_input_store, sizeof(state->text_input_store)); + crypto_explicit_bzero(state->hex_key_input_store, sizeof(state->hex_key_input_store)); + crypto_explicit_bzero(state->key_hex_str, sizeof(state->key_hex_str)); + crypto_ctx_clear(state->crypto_ctx); - /* clear nfc data */ - if (state->nfc_dev_data->parsed_data != NULL) { - furi_string_free(state->nfc_dev_data->parsed_data); - } - crypto_explicit_bzero(state->nfc_dev_data, sizeof(NfcDeviceData)); + /* clear nfc data */ + if(state->nfc_dev_data->parsed_data != NULL) { + furi_string_free(state->nfc_dev_data->parsed_data); + } + crypto_explicit_bzero(state->nfc_dev_data, sizeof(NfcDeviceData)); - /* deinit devices */ - subghz_devices_deinit(); + /* deinit devices */ + subghz_devices_deinit(); - /* exit suppress charge mode */ - furi_hal_power_suppress_charge_exit(); + /* exit suppress charge mode */ + furi_hal_power_suppress_charge_exit(); - /* free everything we allocated */ + /* free everything we allocated */ - crypto_ctx_free(state->crypto_ctx); + crypto_ctx_free(state->crypto_ctx); err_alloc_crypto: - free(state->nfc_dev_data); + free(state->nfc_dev_data); err_alloc_ndevdata: - nfc_worker_free(state->nfc_worker); + nfc_worker_free(state->nfc_worker); err_alloc_nworker: - subghz_tx_rx_worker_free(state->subghz_worker); + subghz_tx_rx_worker_free(state->subghz_worker); err_alloc_worker: - popup_free(state->nfc_popup); + popup_free(state->nfc_popup); err_alloc_np: - dialog_ex_free(state->key_display); + dialog_ex_free(state->key_display); err_alloc_kd: - chat_box_free(state); + chat_box_free(state); err_alloc_cb: - byte_input_free(state->hex_key_input); + byte_input_free(state->hex_key_input); err_alloc_hki: - text_input_free(state->text_input); + text_input_free(state->text_input); err_alloc_ti: - menu_free(state->menu); + menu_free(state->menu); err_alloc_menu: - helper_strings_free(state); + helper_strings_free(state); err_alloc_hs: - view_dispatcher_free(state->view_dispatcher); + view_dispatcher_free(state->view_dispatcher); err_alloc_vd: - scene_manager_free(state->scene_manager); + scene_manager_free(state->scene_manager); err_alloc_sm: - free(state); + free(state); err_alloc: - if (err != 0) { - FURI_LOG_E(APPLICATION_NAME, "Failed to launch (alloc error)!"); - } else { - FURI_LOG_I(APPLICATION_NAME, "Clean exit."); - } + if(err != 0) { + FURI_LOG_E(APPLICATION_NAME, "Failed to launch (alloc error)!"); + } else { + FURI_LOG_I(APPLICATION_NAME, "Clean exit."); + } - return err; + return err; } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_chat_box.c b/applications/external/esubghz_chat/scenes/esubghz_chat_chat_box.c index 49c30ae87..be84ced48 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_chat_box.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_chat_box.c @@ -1,65 +1,59 @@ #include "../esubghz_chat_i.h" /* Prepares the text box scene. */ -void scene_on_enter_chat_box(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_chat_box"); +void scene_on_enter_chat_box(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_chat_box"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - text_box_reset(state->chat_box); - text_box_set_text(state->chat_box, - furi_string_get_cstr(state->chat_box_store)); - text_box_set_focus(state->chat_box, TextBoxFocusEnd); + text_box_reset(state->chat_box); + text_box_set_text(state->chat_box, furi_string_get_cstr(state->chat_box_store)); + text_box_set_focus(state->chat_box, TextBoxFocusEnd); - view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_ChatBox); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_ChatBox); } /* Handles scene manager events for the text box scene. */ -bool scene_on_event_chat_box(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_chat_box"); +bool scene_on_event_chat_box(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_chat_box"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to message input scene */ - case ESubGhzChatEvent_GotoMsgInput: - if (!scene_manager_previous_scene( - state->scene_manager)) { - view_dispatcher_stop(state->view_dispatcher); - } - consumed = true; - break; - case ESubGhzChatEvent_GotoKeyDisplay: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_KeyDisplay); - consumed = true; - break; - } - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to message input scene */ + case ESubGhzChatEvent_GotoMsgInput: + if(!scene_manager_previous_scene(state->scene_manager)) { + view_dispatcher_stop(state->view_dispatcher); + } + consumed = true; + break; + case ESubGhzChatEvent_GotoKeyDisplay: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeyDisplay); + consumed = true; + break; + } + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the text box scene. */ -void scene_on_exit_chat_box(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_chat_box"); +void scene_on_exit_chat_box(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_chat_box"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - text_box_reset(state->chat_box); + text_box_reset(state->chat_box); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_chat_input.c b/applications/external/esubghz_chat/scenes/esubghz_chat_chat_input.c index 3f18dd8d7..721fea676 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_chat_input.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_chat_input.c @@ -6,113 +6,102 @@ * then copied into the TX buffer. The contents of the TX buffer are then * transmitted. The sent message is appended to the text box and a MsgEntered * event is sent to the scene manager to switch to the text box view. */ -static bool chat_input_validator(const char *text, FuriString *error, - void *context) -{ - UNUSED(error); +static bool chat_input_validator(const char* text, FuriString* error, void* context) { + UNUSED(error); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - /* no message, just switch to the text box view */ - if (strlen(text) == 0) { - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_MsgEntered); - return true; - } + /* no message, just switch to the text box view */ + if(strlen(text) == 0) { + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_MsgEntered); + return true; + } - /* concatenate the name prefix and the actual message */ - furi_string_set(state->msg_input, state->name_prefix); - furi_string_cat_str(state->msg_input, ": "); - furi_string_cat_str(state->msg_input, text); + /* concatenate the name prefix and the actual message */ + furi_string_set(state->msg_input, state->name_prefix); + furi_string_cat_str(state->msg_input, ": "); + furi_string_cat_str(state->msg_input, text); - /* append the message to the chat box and prepare message preview */ - append_msg(state, furi_string_get_cstr(state->msg_input)); + /* append the message to the chat box and prepare message preview */ + append_msg(state, furi_string_get_cstr(state->msg_input)); - /* encrypt and transmit message */ - tx_msg_input(state); + /* encrypt and transmit message */ + tx_msg_input(state); - /* clear message input buffer */ - furi_string_set_char(state->msg_input, 0, 0); + /* clear message input buffer */ + furi_string_set_char(state->msg_input, 0, 0); - /* switch to text box view */ - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_MsgEntered); + /* switch to text box view */ + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_MsgEntered); - return true; + return true; } /* Prepares the message input scene. */ -void scene_on_enter_chat_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_chat_input"); +void scene_on_enter_chat_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_chat_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - state->text_input_store[0] = 0; - text_input_reset(state->text_input); - /* use validator for scene change to get around minimum length + state->text_input_store[0] = 0; + text_input_reset(state->text_input); + /* use validator for scene change to get around minimum length * requirement */ - text_input_set_result_callback( - state->text_input, - NULL, - NULL, - state->text_input_store, - sizeof(state->text_input_store), - true); - text_input_set_validator( - state->text_input, - chat_input_validator, - state); - set_chat_input_header(state); + text_input_set_result_callback( + state->text_input, + NULL, + NULL, + state->text_input_store, + sizeof(state->text_input_store), + true); + text_input_set_validator(state->text_input, chat_input_validator, state); + set_chat_input_header(state); - view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Input); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Input); } /* Handles scene manager events for the message input scene. */ -bool scene_on_event_chat_input(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_chat_input"); +bool scene_on_event_chat_input(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_chat_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to text box scene */ - case ESubGhzChatEvent_MsgEntered: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_ChatBox); - consumed = true; - break; - } - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to text box scene */ + case ESubGhzChatEvent_MsgEntered: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_ChatBox); + consumed = true; + break; + } + break; - case SceneManagerEventTypeBack: - /* stop the application if the user presses back here */ - view_dispatcher_stop(state->view_dispatcher); - consumed = true; - break; + case SceneManagerEventTypeBack: + /* stop the application if the user presses back here */ + view_dispatcher_stop(state->view_dispatcher); + consumed = true; + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the password input scene. */ -void scene_on_exit_chat_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_chat_input"); +void scene_on_exit_chat_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_chat_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - text_input_reset(state->text_input); + text_input_reset(state->text_input); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_freq_input.c b/applications/external/esubghz_chat/scenes/esubghz_chat_freq_input.c index 85f954fb0..ccce26418 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_freq_input.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_freq_input.c @@ -2,126 +2,108 @@ /* Sends FreqEntered event to scene manager and displays the frequency in the * text box. */ -static void freq_input_cb(void *context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static void freq_input_cb(void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - furi_string_cat_printf(state->chat_box_store, "Frequency: %lu", - state->frequency); + furi_string_cat_printf(state->chat_box_store, "Frequency: %lu", state->frequency); - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_FreqEntered); + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_FreqEntered); } /* Validates the entered frequency. */ -static bool freq_input_validator(const char *text, FuriString *error, - void *context) -{ - furi_assert(text); - furi_assert(error); +static bool freq_input_validator(const char* text, FuriString* error, void* context) { + furi_assert(text); + furi_assert(error); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - int ret = sscanf(text, "%lu", &(state->frequency)); - if (ret != 1) { - furi_string_printf(error, "Please enter\nfrequency\nin Hz!"); - return false; - } + int ret = sscanf(text, "%lu", &(state->frequency)); + if(ret != 1) { + furi_string_printf(error, "Please enter\nfrequency\nin Hz!"); + return false; + } - if (!subghz_devices_is_frequency_valid(state->subghz_device, - state->frequency)) { - furi_string_printf(error, "Frequency\n%lu\n is invalid!", - state->frequency); - return false; - } + if(!subghz_devices_is_frequency_valid(state->subghz_device, state->frequency)) { + furi_string_printf(error, "Frequency\n%lu\n is invalid!", state->frequency); + return false; + } #ifdef FW_ORIGIN_Official - if (!furi_hal_region_is_frequency_allowed(state->frequency)) { + if(!furi_hal_region_is_frequency_allowed(state->frequency)) { #else /* FW_ORIGIN_Official */ - if (!furi_hal_subghz_is_tx_allowed(state->frequency)) { + if(!furi_hal_subghz_is_tx_allowed(state->frequency)) { #endif /* FW_ORIGIN_Official */ - furi_string_printf(error, "TX forbidden\non frequency\n%lu!", - state->frequency); - return false; - } + furi_string_printf(error, "TX forbidden\non frequency\n%lu!", state->frequency); + return false; + } - return true; + return true; } /* Prepares the frequency input scene. */ -void scene_on_enter_freq_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_freq_input"); +void scene_on_enter_freq_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_freq_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - snprintf(state->text_input_store, TEXT_INPUT_STORE_SIZE, "%lu", - (uint32_t) DEFAULT_FREQ); - text_input_reset(state->text_input); - text_input_set_result_callback( - state->text_input, - freq_input_cb, - state, - state->text_input_store, - sizeof(state->text_input_store), - true); - text_input_set_validator( - state->text_input, - freq_input_validator, - state); - text_input_set_header_text( - state->text_input, - "Frequency"); + snprintf(state->text_input_store, TEXT_INPUT_STORE_SIZE, "%lu", (uint32_t)DEFAULT_FREQ); + text_input_reset(state->text_input); + text_input_set_result_callback( + state->text_input, + freq_input_cb, + state, + state->text_input_store, + sizeof(state->text_input_store), + true); + text_input_set_validator(state->text_input, freq_input_validator, state); + text_input_set_header_text(state->text_input, "Frequency"); - view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Input); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Input); } /* Handles scene manager events for the frequency input scene. */ -bool scene_on_event_freq_input(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_freq_input"); +bool scene_on_event_freq_input(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_freq_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to password input scene */ - case ESubGhzChatEvent_FreqEntered: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_KeyMenu); - consumed = true; - break; - } - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to password input scene */ + case ESubGhzChatEvent_FreqEntered: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeyMenu); + consumed = true; + break; + } + break; - case SceneManagerEventTypeBack: - /* stop the application if the user presses back here */ - view_dispatcher_stop(state->view_dispatcher); - consumed = true; - break; + case SceneManagerEventTypeBack: + /* stop the application if the user presses back here */ + view_dispatcher_stop(state->view_dispatcher); + consumed = true; + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the frequency input scene. */ -void scene_on_exit_freq_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_freq_input"); +void scene_on_exit_freq_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_freq_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - text_input_reset(state->text_input); + text_input_reset(state->text_input); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_hex_key_input.c b/applications/external/esubghz_chat/scenes/esubghz_chat_hex_key_input.c index 560f5478c..564bfde8f 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_hex_key_input.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_hex_key_input.c @@ -2,90 +2,81 @@ /* Sets the entered bytes as the key, enters the chat and sends a HexKeyEntered * event to the scene manager. */ -static void hex_key_input_cb(void* context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static void hex_key_input_cb(void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - /* initiate the crypto context */ - bool ret = crypto_ctx_set_key(state->crypto_ctx, - state->hex_key_input_store, state->name_prefix, - furi_get_tick()); + /* initiate the crypto context */ + bool ret = crypto_ctx_set_key( + state->crypto_ctx, state->hex_key_input_store, state->name_prefix, furi_get_tick()); - /* cleanup */ - crypto_explicit_bzero(state->hex_key_input_store, - sizeof(state->hex_key_input_store)); + /* cleanup */ + crypto_explicit_bzero(state->hex_key_input_store, sizeof(state->hex_key_input_store)); - if (!ret) { - crypto_ctx_clear(state->crypto_ctx); - return; - } + if(!ret) { + crypto_ctx_clear(state->crypto_ctx); + return; + } - state->encrypted = true; + state->encrypted = true; - enter_chat(state); + enter_chat(state); - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_HexKeyEntered); + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_HexKeyEntered); } /* Prepares the hex key input scene. */ -void scene_on_enter_hex_key_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_hex_key_input"); +void scene_on_enter_hex_key_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_hex_key_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - byte_input_set_result_callback(state->hex_key_input, - hex_key_input_cb, - NULL, - state, - state->hex_key_input_store, - sizeof(state->hex_key_input_store)); + byte_input_set_result_callback( + state->hex_key_input, + hex_key_input_cb, + NULL, + state, + state->hex_key_input_store, + sizeof(state->hex_key_input_store)); - view_dispatcher_switch_to_view(state->view_dispatcher, - ESubGhzChatView_HexKeyInput); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_HexKeyInput); } /* Handles scene manager events for the hex key input scene. */ -bool scene_on_event_hex_key_input(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_hex_key_input"); +bool scene_on_event_hex_key_input(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_hex_key_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to message input scene */ - case ESubGhzChatEvent_HexKeyEntered: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_ChatInput); - consumed = true; - break; - } - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to message input scene */ + case ESubGhzChatEvent_HexKeyEntered: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_ChatInput); + consumed = true; + break; + } + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the hex key input scene. */ -void scene_on_exit_hex_key_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_hex_key_input"); +void scene_on_exit_hex_key_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_hex_key_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - crypto_explicit_bzero(state->hex_key_input_store, - sizeof(state->hex_key_input_store)); + crypto_explicit_bzero(state->hex_key_input_store, sizeof(state->hex_key_input_store)); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_key_display.c b/applications/external/esubghz_chat/scenes/esubghz_chat_key_display.c index fbc9e37e2..b682d7d87 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_key_display.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_key_display.c @@ -1,128 +1,145 @@ #include "../esubghz_chat_i.h" -void key_display_result_cb(DialogExResult result, void* context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +void key_display_result_cb(DialogExResult result, void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - switch(result) { - case DialogExResultLeft: - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyDisplayBack); - break; + switch(result) { + case DialogExResultLeft: + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_KeyDisplayBack); + break; - case DialogExResultCenter: - if (state->encrypted) { - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyDisplayShare); - } - break; + case DialogExResultCenter: + if(state->encrypted) { + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_KeyDisplayShare); + } + break; - default: - break; - } + default: + break; + } } /* Prepares the key display scene. */ -void scene_on_enter_key_display(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_display"); +void scene_on_enter_key_display(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_display"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - if (state->encrypted) { - uint8_t key[KEY_BITS / 8]; - crypto_ctx_get_key(state->crypto_ctx, key); - snprintf(state->key_hex_str, KEY_HEX_STR_SIZE, - "%02hX%02hX%02hX%02hX" - "%02hX%02hX%02hX%02hX\n" - "%02hX%02hX%02hX%02hX" - "%02hX%02hX%02hX%02hX\n" - "%02hX%02hX%02hX%02hX" - "%02hX%02hX%02hX%02hX\n" - "%02hX%02hX%02hX%02hX" - "%02hX%02hX%02hX%02hX", - key[0], key[1], key[2], key[3], - key[4], key[5], key[6], key[7], - key[8], key[9], key[10], key[11], - key[12], key[13], key[14], key[15], - key[16], key[17], key[18], key[19], - key[20], key[21], key[22], key[23], - key[24], key[25], key[26], key[27], - key[28], key[29], key[30], key[31]); - crypto_explicit_bzero(key, sizeof(key)); - } else { - strcpy(state->key_hex_str, "No Key"); - } + if(state->encrypted) { + uint8_t key[KEY_BITS / 8]; + crypto_ctx_get_key(state->crypto_ctx, key); + snprintf( + state->key_hex_str, + KEY_HEX_STR_SIZE, + "%02hX%02hX%02hX%02hX" + "%02hX%02hX%02hX%02hX\n" + "%02hX%02hX%02hX%02hX" + "%02hX%02hX%02hX%02hX\n" + "%02hX%02hX%02hX%02hX" + "%02hX%02hX%02hX%02hX\n" + "%02hX%02hX%02hX%02hX" + "%02hX%02hX%02hX%02hX", + key[0], + key[1], + key[2], + key[3], + key[4], + key[5], + key[6], + key[7], + key[8], + key[9], + key[10], + key[11], + key[12], + key[13], + key[14], + key[15], + key[16], + key[17], + key[18], + key[19], + key[20], + key[21], + key[22], + key[23], + key[24], + key[25], + key[26], + key[27], + key[28], + key[29], + key[30], + key[31]); + crypto_explicit_bzero(key, sizeof(key)); + } else { + strcpy(state->key_hex_str, "No Key"); + } - dialog_ex_reset(state->key_display); + dialog_ex_reset(state->key_display); - dialog_ex_set_text(state->key_display, state->key_hex_str, 64, 2, - AlignCenter, AlignTop); + dialog_ex_set_text(state->key_display, state->key_hex_str, 64, 2, AlignCenter, AlignTop); - dialog_ex_set_icon(state->key_display, 0, 0, NULL); + dialog_ex_set_icon(state->key_display, 0, 0, NULL); - dialog_ex_set_left_button_text(state->key_display, "Back"); + dialog_ex_set_left_button_text(state->key_display, "Back"); - if (state->encrypted) { - dialog_ex_set_center_button_text(state->key_display, "Share"); - } + if(state->encrypted) { + dialog_ex_set_center_button_text(state->key_display, "Share"); + } - dialog_ex_set_result_callback(state->key_display, - key_display_result_cb); - dialog_ex_set_context(state->key_display, state); + dialog_ex_set_result_callback(state->key_display, key_display_result_cb); + dialog_ex_set_context(state->key_display, state); - view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_KeyDisplay); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_KeyDisplay); } /* Handles scene manager events for the key display scene. */ -bool scene_on_event_key_display(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_display"); +bool scene_on_event_key_display(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_display"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to message input scene */ - case ESubGhzChatEvent_KeyDisplayBack: - if (!scene_manager_previous_scene( - state->scene_manager)) { - view_dispatcher_stop(state->view_dispatcher); - } - consumed = true; - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to message input scene */ + case ESubGhzChatEvent_KeyDisplayBack: + if(!scene_manager_previous_scene(state->scene_manager)) { + view_dispatcher_stop(state->view_dispatcher); + } + consumed = true; + break; - /* open key sharing popup */ - case ESubGhzChatEvent_KeyDisplayShare: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_KeySharePopup); - consumed = true; - break; - } - break; + /* open key sharing popup */ + case ESubGhzChatEvent_KeyDisplayShare: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeySharePopup); + consumed = true; + break; + } + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the key display scene. */ -void scene_on_exit_key_display(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_display"); +void scene_on_exit_key_display(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_display"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - dialog_ex_reset(state->key_display); - crypto_explicit_bzero(state->key_hex_str, sizeof(state->key_hex_str)); + dialog_ex_reset(state->key_display); + crypto_explicit_bzero(state->key_hex_str, sizeof(state->key_hex_str)); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_key_menu.c b/applications/external/esubghz_chat/scenes/esubghz_chat_key_menu.c index 3665003e1..4e54e692f 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_key_menu.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_key_menu.c @@ -1,194 +1,162 @@ #include "../esubghz_chat_i.h" typedef enum { - ESubGhzChatKeyMenuItems_NoEncryption, - ESubGhzChatKeyMenuItems_Password, - ESubGhzChatKeyMenuItems_HexKey, - ESubGhzChatKeyMenuItems_GenKey, - ESubGhzChatKeyMenuItems_ReadKeyFromNfc, + ESubGhzChatKeyMenuItems_NoEncryption, + ESubGhzChatKeyMenuItems_Password, + ESubGhzChatKeyMenuItems_HexKey, + ESubGhzChatKeyMenuItems_GenKey, + ESubGhzChatKeyMenuItems_ReadKeyFromNfc, } ESubGhzChatKeyMenuItems; -static void key_menu_cb(void* context, uint32_t index) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static void key_menu_cb(void* context, uint32_t index) { + furi_assert(context); + ESubGhzChatState* state = context; - uint8_t key[KEY_BITS / 8]; + uint8_t key[KEY_BITS / 8]; - switch(index) { - case ESubGhzChatKeyMenuItems_NoEncryption: - state->encrypted = false; - enter_chat(state); + switch(index) { + case ESubGhzChatKeyMenuItems_NoEncryption: + state->encrypted = false; + enter_chat(state); - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyMenuNoEncryption); - break; + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_KeyMenuNoEncryption); + break; - case ESubGhzChatKeyMenuItems_Password: - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyMenuPassword); - break; + case ESubGhzChatKeyMenuItems_Password: + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_KeyMenuPassword); + break; - case ESubGhzChatKeyMenuItems_HexKey: - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyMenuHexKey); - break; + case ESubGhzChatKeyMenuItems_HexKey: + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_KeyMenuHexKey); + break; - case ESubGhzChatKeyMenuItems_GenKey: - /* generate a random key */ - furi_hal_random_fill_buf(key, KEY_BITS / 8); + case ESubGhzChatKeyMenuItems_GenKey: + /* generate a random key */ + furi_hal_random_fill_buf(key, KEY_BITS / 8); - /* initiate the crypto context */ - bool ret = crypto_ctx_set_key(state->crypto_ctx, key, - state->name_prefix, furi_get_tick()); + /* initiate the crypto context */ + bool ret = crypto_ctx_set_key(state->crypto_ctx, key, state->name_prefix, furi_get_tick()); - /* cleanup */ - crypto_explicit_bzero(key, sizeof(key)); + /* cleanup */ + crypto_explicit_bzero(key, sizeof(key)); - if (!ret) { - crypto_ctx_clear(state->crypto_ctx); - return; - } + if(!ret) { + crypto_ctx_clear(state->crypto_ctx); + return; + } - /* set encrypted flag and enter the chat */ - state->encrypted = true; - enter_chat(state); + /* set encrypted flag and enter the chat */ + state->encrypted = true; + enter_chat(state); - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyMenuGenKey); - break; + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_KeyMenuGenKey); + break; - case ESubGhzChatKeyMenuItems_ReadKeyFromNfc: - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyMenuReadKeyFromNfc); - break; + case ESubGhzChatKeyMenuItems_ReadKeyFromNfc: + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_KeyMenuReadKeyFromNfc); + break; - default: - break; - } + default: + break; + } } /* Prepares the key menu scene. */ -void scene_on_enter_key_menu(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_menu"); +void scene_on_enter_key_menu(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_menu"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - menu_reset(state->menu); + menu_reset(state->menu); - menu_add_item( - state->menu, - "No encryption", - NULL, - ESubGhzChatKeyMenuItems_NoEncryption, - key_menu_cb, - state - ); - menu_add_item( - state->menu, - "Password", - NULL, - ESubGhzChatKeyMenuItems_Password, - key_menu_cb, - state - ); - menu_add_item( - state->menu, - "Hex Key", - NULL, - ESubGhzChatKeyMenuItems_HexKey, - key_menu_cb, - state - ); - menu_add_item( - state->menu, - "Generate Key", - NULL, - ESubGhzChatKeyMenuItems_GenKey, - key_menu_cb, - state - ); - menu_add_item( - state->menu, - "Read Key from NFC", - NULL, - ESubGhzChatKeyMenuItems_ReadKeyFromNfc, - key_menu_cb, - state - ); + menu_add_item( + state->menu, + "No encryption", + NULL, + ESubGhzChatKeyMenuItems_NoEncryption, + key_menu_cb, + state); + menu_add_item( + state->menu, "Password", NULL, ESubGhzChatKeyMenuItems_Password, key_menu_cb, state); + menu_add_item( + state->menu, "Hex Key", NULL, ESubGhzChatKeyMenuItems_HexKey, key_menu_cb, state); + menu_add_item( + state->menu, "Generate Key", NULL, ESubGhzChatKeyMenuItems_GenKey, key_menu_cb, state); + menu_add_item( + state->menu, + "Read Key from NFC", + NULL, + ESubGhzChatKeyMenuItems_ReadKeyFromNfc, + key_menu_cb, + state); - view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Menu); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Menu); } /* Handles scene manager events for the key menu scene. */ -bool scene_on_event_key_menu(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_menu"); +bool scene_on_event_key_menu(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_menu"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to message input scene */ - case ESubGhzChatEvent_KeyMenuNoEncryption: - case ESubGhzChatEvent_KeyMenuGenKey: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_ChatInput); - consumed = true; - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to message input scene */ + case ESubGhzChatEvent_KeyMenuNoEncryption: + case ESubGhzChatEvent_KeyMenuGenKey: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_ChatInput); + consumed = true; + break; - /* switch to password input scene */ - case ESubGhzChatEvent_KeyMenuPassword: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_PassInput); - consumed = true; - break; + /* switch to password input scene */ + case ESubGhzChatEvent_KeyMenuPassword: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_PassInput); + consumed = true; + break; - /* switch to hex key input scene */ - case ESubGhzChatEvent_KeyMenuHexKey: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_HexKeyInput); - consumed = true; - break; + /* switch to hex key input scene */ + case ESubGhzChatEvent_KeyMenuHexKey: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_HexKeyInput); + consumed = true; + break; - /* switch to hex key read scene */ - case ESubGhzChatEvent_KeyMenuReadKeyFromNfc: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_KeyReadPopup); - consumed = true; - break; - } + /* switch to hex key read scene */ + case ESubGhzChatEvent_KeyMenuReadKeyFromNfc: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_KeyReadPopup); + consumed = true; + break; + } - break; + break; - case SceneManagerEventTypeBack: - /* stop the application if the user presses back here */ - view_dispatcher_stop(state->view_dispatcher); - consumed = true; - break; + case SceneManagerEventTypeBack: + /* stop the application if the user presses back here */ + view_dispatcher_stop(state->view_dispatcher); + consumed = true; + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the key menu scene. */ -void scene_on_exit_key_menu(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_menu"); +void scene_on_exit_key_menu(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_menu"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - menu_reset(state->menu); + menu_reset(state->menu); } - diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_key_read_popup.c b/applications/external/esubghz_chat/scenes/esubghz_chat_key_read_popup.c index d06b14632..4d5904406 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_key_read_popup.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_key_read_popup.c @@ -1,251 +1,229 @@ #include "../esubghz_chat_i.h" typedef enum { - KeyReadPopupState_Idle, - KeyReadPopupState_Detecting, - KeyReadPopupState_Reading, - KeyReadPopupState_Fail, - KeyReadPopupState_Success, + KeyReadPopupState_Idle, + KeyReadPopupState_Detecting, + KeyReadPopupState_Reading, + KeyReadPopupState_Fail, + KeyReadPopupState_Success, } KeyReadPopupState; -static bool read_worker_cb(NfcWorkerEvent event, void* context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static bool read_worker_cb(NfcWorkerEvent event, void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - view_dispatcher_send_custom_event(state->view_dispatcher, event); + view_dispatcher_send_custom_event(state->view_dispatcher, event); - return true; + return true; } -static void key_read_popup_timeout_cb(void* context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static void key_read_popup_timeout_cb(void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - uint32_t cur_state = scene_manager_get_scene_state( - state->scene_manager, ESubGhzChatScene_KeyReadPopup); + uint32_t cur_state = + scene_manager_get_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup); - /* done displaying our failure */ - if (cur_state == KeyReadPopupState_Fail) { - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyReadPopupFailed); - /* done displaying our success, enter chat */ - } else if (cur_state == KeyReadPopupState_Success) { - enter_chat(state); - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_KeyReadPopupSucceeded); - } + /* done displaying our failure */ + if(cur_state == KeyReadPopupState_Fail) { + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_KeyReadPopupFailed); + /* done displaying our success, enter chat */ + } else if(cur_state == KeyReadPopupState_Success) { + enter_chat(state); + view_dispatcher_send_custom_event( + state->view_dispatcher, ESubGhzChatEvent_KeyReadPopupSucceeded); + } } -static bool key_read_popup_handle_key_read(ESubGhzChatState *state) -{ - NfcDeviceData *dev_data = state->nfc_dev_data; +static bool key_read_popup_handle_key_read(ESubGhzChatState* state) { + NfcDeviceData* dev_data = state->nfc_dev_data; - if (dev_data->mf_ul_data.data_read < KEY_BITS / 8) { - return false; - } + if(dev_data->mf_ul_data.data_read < KEY_BITS / 8) { + return false; + } - /* initiate the crypto context */ - bool ret = crypto_ctx_set_key(state->crypto_ctx, - dev_data->mf_ul_data.data, state->name_prefix, - furi_get_tick()); + /* initiate the crypto context */ + bool ret = crypto_ctx_set_key( + state->crypto_ctx, dev_data->mf_ul_data.data, state->name_prefix, furi_get_tick()); - /* cleanup */ - crypto_explicit_bzero(dev_data->mf_ul_data.data, KEY_BITS / 8); + /* cleanup */ + crypto_explicit_bzero(dev_data->mf_ul_data.data, KEY_BITS / 8); - if (!ret) { - crypto_ctx_clear(state->crypto_ctx); - return false; - } + if(!ret) { + crypto_ctx_clear(state->crypto_ctx); + return false; + } - /* set encrypted flag */ - state->encrypted = true; + /* set encrypted flag */ + state->encrypted = true; - return true; + return true; } -static void key_read_popup_set_state(ESubGhzChatState *state, KeyReadPopupState - new_state) -{ - uint32_t cur_state = scene_manager_get_scene_state( - state->scene_manager, ESubGhzChatScene_KeyReadPopup); - if (cur_state == new_state) { - return; - } +static void key_read_popup_set_state(ESubGhzChatState* state, KeyReadPopupState new_state) { + uint32_t cur_state = + scene_manager_get_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup); + if(cur_state == new_state) { + return; + } - if (new_state == KeyReadPopupState_Detecting) { - popup_reset(state->nfc_popup); - popup_disable_timeout(state->nfc_popup); - popup_set_text(state->nfc_popup, "Tap Flipper\n to sender", 97, - 24, AlignCenter, AlignTop); - popup_set_icon(state->nfc_popup, 0, 8, &I_NFC_manual_60x50); - notification_message(state->notification, - &sequence_blink_start_cyan); - } else if (new_state == KeyReadPopupState_Reading) { - popup_reset(state->nfc_popup); - popup_disable_timeout(state->nfc_popup); - popup_set_header(state->nfc_popup, "Reading key\nDon't " - "move...", 85, 24, AlignCenter, AlignTop); - popup_set_icon(state->nfc_popup, 12, 23, &I_Loading_24); - notification_message(state->notification, - &sequence_blink_start_yellow); - } else if (new_state == KeyReadPopupState_Fail) { - nfc_worker_stop(state->nfc_worker); + if(new_state == KeyReadPopupState_Detecting) { + popup_reset(state->nfc_popup); + popup_disable_timeout(state->nfc_popup); + popup_set_text(state->nfc_popup, "Tap Flipper\n to sender", 97, 24, AlignCenter, AlignTop); + popup_set_icon(state->nfc_popup, 0, 8, &I_NFC_manual_60x50); + notification_message(state->notification, &sequence_blink_start_cyan); + } else if(new_state == KeyReadPopupState_Reading) { + popup_reset(state->nfc_popup); + popup_disable_timeout(state->nfc_popup); + popup_set_header( + state->nfc_popup, + "Reading key\nDon't " + "move...", + 85, + 24, + AlignCenter, + AlignTop); + popup_set_icon(state->nfc_popup, 12, 23, &I_Loading_24); + notification_message(state->notification, &sequence_blink_start_yellow); + } else if(new_state == KeyReadPopupState_Fail) { + nfc_worker_stop(state->nfc_worker); - popup_reset(state->nfc_popup); - popup_set_header(state->nfc_popup, "Failure!", 64, 2, - AlignCenter, AlignTop); - popup_set_text(state->nfc_popup, "Failed\nto read\nkey.", 78, - 16, AlignLeft, AlignTop); - popup_set_icon(state->nfc_popup, 21, 13, &I_Cry_dolph_55x52); + popup_reset(state->nfc_popup); + popup_set_header(state->nfc_popup, "Failure!", 64, 2, AlignCenter, AlignTop); + popup_set_text(state->nfc_popup, "Failed\nto read\nkey.", 78, 16, AlignLeft, AlignTop); + popup_set_icon(state->nfc_popup, 21, 13, &I_Cry_dolph_55x52); - popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS); - popup_set_context(state->nfc_popup, state); - popup_set_callback(state->nfc_popup, - key_read_popup_timeout_cb); - popup_enable_timeout(state->nfc_popup); + popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS); + popup_set_context(state->nfc_popup, state); + popup_set_callback(state->nfc_popup, key_read_popup_timeout_cb); + popup_enable_timeout(state->nfc_popup); - notification_message(state->notification, - &sequence_blink_stop); - } else if (new_state == KeyReadPopupState_Success) { - nfc_worker_stop(state->nfc_worker); + notification_message(state->notification, &sequence_blink_stop); + } else if(new_state == KeyReadPopupState_Success) { + nfc_worker_stop(state->nfc_worker); - popup_reset(state->nfc_popup); - popup_set_header(state->nfc_popup, "Key\nread!", 13, 22, - AlignLeft, AlignBottom); - popup_set_icon(state->nfc_popup, 32, 5, &I_DolphinNice_96x59); + popup_reset(state->nfc_popup); + popup_set_header(state->nfc_popup, "Key\nread!", 13, 22, AlignLeft, AlignBottom); + popup_set_icon(state->nfc_popup, 32, 5, &I_DolphinNice_96x59); - popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS); - popup_set_context(state->nfc_popup, state); - popup_set_callback(state->nfc_popup, - key_read_popup_timeout_cb); - popup_enable_timeout(state->nfc_popup); + popup_set_timeout(state->nfc_popup, KEY_READ_POPUP_MS); + popup_set_context(state->nfc_popup, state); + popup_set_callback(state->nfc_popup, key_read_popup_timeout_cb); + popup_enable_timeout(state->nfc_popup); - notification_message(state->notification, &sequence_success); - notification_message(state->notification, - &sequence_blink_stop); - } + notification_message(state->notification, &sequence_success); + notification_message(state->notification, &sequence_blink_stop); + } - scene_manager_set_scene_state(state->scene_manager, - ESubGhzChatScene_KeyReadPopup, new_state); + scene_manager_set_scene_state(state->scene_manager, ESubGhzChatScene_KeyReadPopup, new_state); - view_dispatcher_switch_to_view(state->view_dispatcher, - ESubGhzChatView_NfcPopup); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_NfcPopup); } /* Prepares the key share read scene. */ -void scene_on_enter_key_read_popup(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_read_popup"); +void scene_on_enter_key_read_popup(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_read_popup"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - key_read_popup_set_state(state, KeyReadPopupState_Detecting); + key_read_popup_set_state(state, KeyReadPopupState_Detecting); - state->nfc_dev_data->parsed_data = furi_string_alloc(); - if (state->nfc_dev_data->parsed_data == NULL) { - /* can't do anything here, crash */ - furi_check(0); - } + state->nfc_dev_data->parsed_data = furi_string_alloc(); + if(state->nfc_dev_data->parsed_data == NULL) { + /* can't do anything here, crash */ + furi_check(0); + } - nfc_worker_start(state->nfc_worker, NfcWorkerStateRead, - state->nfc_dev_data, read_worker_cb, state); + nfc_worker_start( + state->nfc_worker, NfcWorkerStateRead, state->nfc_dev_data, read_worker_cb, state); } /* Handles scene manager events for the key read popup scene. */ -bool scene_on_event_key_read_popup(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_read_popup"); +bool scene_on_event_key_read_popup(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_read_popup"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* card detected */ - case NfcWorkerEventCardDetected: - key_read_popup_set_state(state, - KeyReadPopupState_Reading); - consumed = true; - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* card detected */ + case NfcWorkerEventCardDetected: + key_read_popup_set_state(state, KeyReadPopupState_Reading); + consumed = true; + break; - /* no card detected */ - case NfcWorkerEventNoCardDetected: - key_read_popup_set_state(state, - KeyReadPopupState_Detecting); - consumed = true; - break; + /* no card detected */ + case NfcWorkerEventNoCardDetected: + key_read_popup_set_state(state, KeyReadPopupState_Detecting); + consumed = true; + break; - /* key probably read */ - case NfcWorkerEventReadMfUltralight: - if (key_read_popup_handle_key_read(state)) { - key_read_popup_set_state(state, - KeyReadPopupState_Success); - } else { - key_read_popup_set_state(state, - KeyReadPopupState_Fail); - } - consumed = true; - break; + /* key probably read */ + case NfcWorkerEventReadMfUltralight: + if(key_read_popup_handle_key_read(state)) { + key_read_popup_set_state(state, KeyReadPopupState_Success); + } else { + key_read_popup_set_state(state, KeyReadPopupState_Fail); + } + consumed = true; + break; - /* close the popup and go back */ - case ESubGhzChatEvent_KeyReadPopupFailed: - if (!scene_manager_previous_scene( - state->scene_manager)) { - view_dispatcher_stop(state->view_dispatcher); - } - consumed = true; - break; + /* close the popup and go back */ + case ESubGhzChatEvent_KeyReadPopupFailed: + if(!scene_manager_previous_scene(state->scene_manager)) { + view_dispatcher_stop(state->view_dispatcher); + } + consumed = true; + break; - /* success, go to chat input */ - case ESubGhzChatEvent_KeyReadPopupSucceeded: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_ChatInput); - consumed = true; - break; + /* success, go to chat input */ + case ESubGhzChatEvent_KeyReadPopupSucceeded: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_ChatInput); + consumed = true; + break; - /* something else happend, treat as failure */ - default: - key_read_popup_set_state(state, - KeyReadPopupState_Fail); - consumed = true; - break; - } + /* something else happend, treat as failure */ + default: + key_read_popup_set_state(state, KeyReadPopupState_Fail); + consumed = true; + break; + } - break; + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the key read popup scene. */ -void scene_on_exit_key_read_popup(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_read_popup"); +void scene_on_exit_key_read_popup(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_read_popup"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - popup_reset(state->nfc_popup); - scene_manager_set_scene_state(state->scene_manager, - ESubGhzChatScene_KeyReadPopup, KeyReadPopupState_Idle); + popup_reset(state->nfc_popup); + scene_manager_set_scene_state( + state->scene_manager, ESubGhzChatScene_KeyReadPopup, KeyReadPopupState_Idle); - notification_message(state->notification, &sequence_blink_stop); + notification_message(state->notification, &sequence_blink_stop); - nfc_worker_stop(state->nfc_worker); + nfc_worker_stop(state->nfc_worker); - crypto_explicit_bzero(state->nfc_dev_data->mf_ul_data.data, KEY_BITS / 8); - if (state->nfc_dev_data->parsed_data != NULL) { - furi_string_free(state->nfc_dev_data->parsed_data); - } - memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData)); + crypto_explicit_bzero(state->nfc_dev_data->mf_ul_data.data, KEY_BITS / 8); + if(state->nfc_dev_data->parsed_data != NULL) { + furi_string_free(state->nfc_dev_data->parsed_data); + } + memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData)); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_key_share_popup.c b/applications/external/esubghz_chat/scenes/esubghz_chat_key_share_popup.c index d5c40dced..a3230049c 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_key_share_popup.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_key_share_popup.c @@ -1,88 +1,80 @@ #include "../esubghz_chat_i.h" -static void prepare_nfc_dev_data(ESubGhzChatState *state) -{ - NfcDeviceData *dev_data = state->nfc_dev_data; +static void prepare_nfc_dev_data(ESubGhzChatState* state) { + NfcDeviceData* dev_data = state->nfc_dev_data; - dev_data->protocol = NfcDeviceProtocolMifareUl; - furi_hal_random_fill_buf(dev_data->nfc_data.uid, 7); - dev_data->nfc_data.uid_len = 7; - dev_data->nfc_data.atqa[0] = 0x44; - dev_data->nfc_data.atqa[1] = 0x00; - dev_data->nfc_data.sak = 0x00; + dev_data->protocol = NfcDeviceProtocolMifareUl; + furi_hal_random_fill_buf(dev_data->nfc_data.uid, 7); + dev_data->nfc_data.uid_len = 7; + dev_data->nfc_data.atqa[0] = 0x44; + dev_data->nfc_data.atqa[1] = 0x00; + dev_data->nfc_data.sak = 0x00; - dev_data->mf_ul_data.type = MfUltralightTypeNTAG215; - dev_data->mf_ul_data.version.header = 0x00; - dev_data->mf_ul_data.version.vendor_id = 0x04; - dev_data->mf_ul_data.version.prod_type = 0x04; - dev_data->mf_ul_data.version.prod_subtype = 0x02; - dev_data->mf_ul_data.version.prod_ver_major = 0x01; - dev_data->mf_ul_data.version.prod_ver_minor = 0x00; - dev_data->mf_ul_data.version.storage_size = 0x11; - dev_data->mf_ul_data.version.protocol_type = 0x03; + dev_data->mf_ul_data.type = MfUltralightTypeNTAG215; + dev_data->mf_ul_data.version.header = 0x00; + dev_data->mf_ul_data.version.vendor_id = 0x04; + dev_data->mf_ul_data.version.prod_type = 0x04; + dev_data->mf_ul_data.version.prod_subtype = 0x02; + dev_data->mf_ul_data.version.prod_ver_major = 0x01; + dev_data->mf_ul_data.version.prod_ver_minor = 0x00; + dev_data->mf_ul_data.version.storage_size = 0x11; + dev_data->mf_ul_data.version.protocol_type = 0x03; - /* Add 16 to the size for config pages */ - dev_data->mf_ul_data.data_size = (KEY_BITS / 8) + 16; - crypto_ctx_get_key(state->crypto_ctx, dev_data->mf_ul_data.data); + /* Add 16 to the size for config pages */ + dev_data->mf_ul_data.data_size = (KEY_BITS / 8) + 16; + crypto_ctx_get_key(state->crypto_ctx, dev_data->mf_ul_data.data); } /* Prepares the key share popup scene. */ -void scene_on_enter_key_share_popup(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_share_popup"); +void scene_on_enter_key_share_popup(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_key_share_popup"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - popup_reset(state->nfc_popup); + popup_reset(state->nfc_popup); - popup_disable_timeout(state->nfc_popup); + popup_disable_timeout(state->nfc_popup); - popup_set_header(state->nfc_popup, "Sharing...", 67, 13, AlignLeft, - AlignTop); - popup_set_icon(state->nfc_popup, 0, 3, &I_NFC_dolphin_emulation_47x61); - popup_set_text(state->nfc_popup, "Sharing\nKey via\nNFC", 90, 28, - AlignCenter, AlignTop); + popup_set_header(state->nfc_popup, "Sharing...", 67, 13, AlignLeft, AlignTop); + popup_set_icon(state->nfc_popup, 0, 3, &I_NFC_dolphin_emulation_47x61); + popup_set_text(state->nfc_popup, "Sharing\nKey via\nNFC", 90, 28, AlignCenter, AlignTop); - prepare_nfc_dev_data(state); - nfc_worker_start(state->nfc_worker, NfcWorkerStateMfUltralightEmulate, - state->nfc_dev_data, NULL, NULL); + prepare_nfc_dev_data(state); + nfc_worker_start( + state->nfc_worker, NfcWorkerStateMfUltralightEmulate, state->nfc_dev_data, NULL, NULL); - notification_message(state->notification, - &sequence_blink_start_magenta); + notification_message(state->notification, &sequence_blink_start_magenta); - view_dispatcher_switch_to_view(state->view_dispatcher, - ESubGhzChatView_NfcPopup); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_NfcPopup); } /* Handles scene manager events for the key share popup scene. */ -bool scene_on_event_key_share_popup(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_share_popup"); +bool scene_on_event_key_share_popup(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_key_share_popup"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - UNUSED(state); - UNUSED(event); + UNUSED(state); + UNUSED(event); - return false; + return false; } /* Cleans up the key share popup scene. */ -void scene_on_exit_key_share_popup(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_share_popup"); +void scene_on_exit_key_share_popup(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_key_share_popup"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - popup_reset(state->nfc_popup); + popup_reset(state->nfc_popup); - notification_message(state->notification, &sequence_blink_stop); + notification_message(state->notification, &sequence_blink_stop); - nfc_worker_stop(state->nfc_worker); + nfc_worker_stop(state->nfc_worker); - crypto_explicit_bzero(state->nfc_dev_data->mf_ul_data.data, KEY_BITS / 8); - memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData)); + crypto_explicit_bzero(state->nfc_dev_data->mf_ul_data.data, KEY_BITS / 8); + memset(state->nfc_dev_data, 0, sizeof(NfcDeviceData)); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_pass_input.c b/applications/external/esubghz_chat/scenes/esubghz_chat_pass_input.c index 6dcf15c74..cb40fc7fd 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_pass_input.c +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_pass_input.c @@ -1,127 +1,111 @@ #include "../esubghz_chat_i.h" /* Sends PassEntered event to scene manager and enters the chat. */ -static void pass_input_cb(void *context) -{ - furi_assert(context); - ESubGhzChatState* state = context; +static void pass_input_cb(void* context) { + furi_assert(context); + ESubGhzChatState* state = context; - crypto_explicit_bzero(state->text_input_store, - sizeof(state->text_input_store)); + crypto_explicit_bzero(state->text_input_store, sizeof(state->text_input_store)); - enter_chat(state); + enter_chat(state); - view_dispatcher_send_custom_event(state->view_dispatcher, - ESubGhzChatEvent_PassEntered); + view_dispatcher_send_custom_event(state->view_dispatcher, ESubGhzChatEvent_PassEntered); } /* If a password was entered this derives a key from the password using a * single pass of SHA256 and initiates the AES-GCM context for encryption. If * the initiation fails, the password is rejected. */ -static bool pass_input_validator(const char *text, FuriString *error, - void *context) -{ - furi_assert(text); - furi_assert(error); +static bool pass_input_validator(const char* text, FuriString* error, void* context) { + furi_assert(text); + furi_assert(error); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - if (strlen(text) == 0) { - furi_string_printf(error, "Enter a\npassword!"); - return false; - } + if(strlen(text) == 0) { + furi_string_printf(error, "Enter a\npassword!"); + return false; + } - unsigned char key[KEY_BITS / 8]; + unsigned char key[KEY_BITS / 8]; - /* derive a key from the password */ - sha256((unsigned char *) text, strlen(text), key); + /* derive a key from the password */ + sha256((unsigned char*)text, strlen(text), key); - /* initiate the crypto context */ - bool ret = crypto_ctx_set_key(state->crypto_ctx, key, - state->name_prefix, furi_get_tick()); + /* initiate the crypto context */ + bool ret = crypto_ctx_set_key(state->crypto_ctx, key, state->name_prefix, furi_get_tick()); - /* cleanup */ - crypto_explicit_bzero(key, sizeof(key)); + /* cleanup */ + crypto_explicit_bzero(key, sizeof(key)); - if (!ret) { - crypto_ctx_clear(state->crypto_ctx); - furi_string_printf(error, "Failed to\nset key!"); - return false; - } + if(!ret) { + crypto_ctx_clear(state->crypto_ctx); + furi_string_printf(error, "Failed to\nset key!"); + return false; + } - state->encrypted = true; + state->encrypted = true; - return true; + return true; } /* Prepares the password input scene. */ -void scene_on_enter_pass_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_pass_input"); +void scene_on_enter_pass_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_enter_pass_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - state->text_input_store[0] = 0; - text_input_reset(state->text_input); - text_input_set_result_callback( - state->text_input, - pass_input_cb, - state, - state->text_input_store, - sizeof(state->text_input_store), - true); - text_input_set_validator( - state->text_input, - pass_input_validator, - state); - text_input_set_header_text( - state->text_input, - "Password"); + state->text_input_store[0] = 0; + text_input_reset(state->text_input); + text_input_set_result_callback( + state->text_input, + pass_input_cb, + state, + state->text_input_store, + sizeof(state->text_input_store), + true); + text_input_set_validator(state->text_input, pass_input_validator, state); + text_input_set_header_text(state->text_input, "Password"); - view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Input); + view_dispatcher_switch_to_view(state->view_dispatcher, ESubGhzChatView_Input); } /* Handles scene manager events for the password input scene. */ -bool scene_on_event_pass_input(void* context, SceneManagerEvent event) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_event_pass_input"); +bool scene_on_event_pass_input(void* context, SceneManagerEvent event) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_event_pass_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - bool consumed = false; + bool consumed = false; - switch(event.type) { - case SceneManagerEventTypeCustom: - switch(event.event) { - /* switch to message input scene */ - case ESubGhzChatEvent_PassEntered: - scene_manager_next_scene(state->scene_manager, - ESubGhzChatScene_ChatInput); - consumed = true; - break; - } - break; + switch(event.type) { + case SceneManagerEventTypeCustom: + switch(event.event) { + /* switch to message input scene */ + case ESubGhzChatEvent_PassEntered: + scene_manager_next_scene(state->scene_manager, ESubGhzChatScene_ChatInput); + consumed = true; + break; + } + break; - default: - consumed = false; - break; - } + default: + consumed = false; + break; + } - return consumed; + return consumed; } /* Cleans up the password input scene. */ -void scene_on_exit_pass_input(void* context) -{ - FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_pass_input"); +void scene_on_exit_pass_input(void* context) { + FURI_LOG_T(APPLICATION_NAME, "scene_on_exit_pass_input"); - furi_assert(context); - ESubGhzChatState* state = context; + furi_assert(context); + ESubGhzChatState* state = context; - text_input_reset(state->text_input); - crypto_explicit_bzero(state->text_input_store, - sizeof(state->text_input_store)); + text_input_reset(state->text_input); + crypto_explicit_bzero(state->text_input_store, sizeof(state->text_input_store)); } diff --git a/applications/external/esubghz_chat/scenes/esubghz_chat_scene.h b/applications/external/esubghz_chat/scenes/esubghz_chat_scene.h index 45663e6dd..3f57d2cc7 100644 --- a/applications/external/esubghz_chat/scenes/esubghz_chat_scene.h +++ b/applications/external/esubghz_chat/scenes/esubghz_chat_scene.h @@ -6,7 +6,7 @@ #define ADD_SCENE(prefix, name, id) ESubGhzChatScene_##id, typedef enum { #include "esubghz_chat_scene_config.h" - ESubGhzChatScene_MAX + ESubGhzChatScene_MAX } ESubGhzChatScene; #undef ADD_SCENE @@ -19,7 +19,7 @@ extern const SceneManagerHandlers esubghz_chat_scene_event_handlers; // Generate scene on_event handlers declaration #define ADD_SCENE(prefix, name, id) \ - bool scene_on_event_##name(void* context, SceneManagerEvent event); + bool scene_on_event_##name(void* context, SceneManagerEvent event); #include "esubghz_chat_scene_config.h" #undef ADD_SCENE diff --git a/applications/external/wire_tester/wire_tester.c b/applications/external/wire_tester/wire_tester.c index 02fe4dd0f..8b1b565d1 100644 --- a/applications/external/wire_tester/wire_tester.c +++ b/applications/external/wire_tester/wire_tester.c @@ -9,23 +9,20 @@ #include "wire_tester_icons.h" - //#define TAG "wire_tester" - static const uint32_t EVENT_PERIOD_MS = 10; // check for input changes often static const float BEEP_FREQ = 2400.0f; // louder than other frequencies static const float BEEP_VOL = 0.8f; static const GpioPin* const INPUT_PIN = &gpio_ext_pb2; // pin 6 - static void start_feedback(NotificationApp* notifications) { // set LED to green notification_message_block(notifications, &sequence_set_only_green_255); // start beep - if (furi_hal_speaker_acquire(1000)) { - furi_hal_speaker_start(BEEP_FREQ, BEEP_VOL); + if(furi_hal_speaker_acquire(1000)) { + furi_hal_speaker_start(BEEP_FREQ, BEEP_VOL); } } @@ -34,7 +31,7 @@ static void stop_feedback(NotificationApp* notifications) { notification_message_block(notifications, &sequence_reset_rgb); // stop beep - if (furi_hal_speaker_is_mine()) { + if(furi_hal_speaker_is_mine()) { furi_hal_speaker_stop(); furi_hal_speaker_release(); } @@ -75,21 +72,21 @@ int32_t app_main(void* p) { bool alarming = false; bool running = true; - while (running) { + while(running) { // start and stop feedback on the transition bool continuous = !furi_hal_gpio_read(INPUT_PIN); - if (continuous && !alarming) { + if(continuous && !alarming) { start_feedback(notifications); - } else if (!continuous && alarming) { + } else if(!continuous && alarming) { stop_feedback(notifications); } alarming = continuous; // exit on back key InputEvent event; - if (furi_message_queue_get(event_queue, &event, EVENT_PERIOD_MS) == FuriStatusOk) { - if ((event.type == InputTypePress || event.type == InputTypeRepeat) - && event.key == InputKeyBack) { + if(furi_message_queue_get(event_queue, &event, EVENT_PERIOD_MS) == FuriStatusOk) { + if((event.type == InputTypePress || event.type == InputTypeRepeat) && + event.key == InputKeyBack) { running = false; } }