1 /*

     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Class for parsing GB 15629.11 (WAPI) IEs.

    15 *

    16 */

    17 

    18 

    19 #include "core_frame_wapi_ie.h"

    20 #include "core_tools.h"

    21 #include "core_tools_parser.h"

    22 #include "am_debug.h"

    23 

    24 const u8_t CORE_FRAME_WAPI_IE_MIN_LENGTH = 22;

    25 const u8_t CORE_FRAME_WAPI_IE_BKID_COUNT_SIZE = 2;

    26 const u8_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_OFFSET = 4;

    27 const u8_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_SIZE = 2;

    28 const u8_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_OUI_LENGTH = 4;

    29 const u8_t CORE_FRAME_WAPI_IE_CIPHER_COUNT_SIZE = 2;

    30 const u8_t CORE_FRAME_WAPI_IE_CIPHER_OUI_LENGTH = 4;

    31 

    32 /** IDs for different cipher suites in WAPI IE. */

    33 const u8_t CORE_FRAME_WAPI_IE_CIPHER_ID_NONE    = 0x00;

    34 const u8_t CORE_FRAME_WAPI_IE_CIPHER_ID_WPI     = 0x01;

    35 

    36 /** IDs for different key management suites. */

    37 const u8_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_NONE = 0x00;

    38 const u8_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_CERTIFICATE = 0x01;

    39 const u8_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_PSK  = 0x02;

    40 

    41 const u8_t CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH = 3;

    42 const u8_t CORE_FRAME_WAPI_IE_OUI_PREFIX[] = { 0x00, 0x14, 0x72 };

    43 

    44 const u16_t CORE_FRAME_WAPI_IE_VERSION = 1;

    45 const u16_t CORE_FRAME_WAPI_IE_PAIRWISE_SUITE_COUNT = 1;

    46 const u16_t CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT = 1;

    47 const u16_t CORE_FRAME_WAPI_IE_BKID_COUNT = 1;

    48 const u16_t CORE_FRAME_WAPI_IE_BKID_LENGTH = 16;

    49 

    50 // ---------------------------------------------------------------------------

    51 // ---------------------------------------------------------------------------

    52 //

    53 core_frame_wapi_ie_c* core_frame_wapi_ie_c::instance(

    54     const core_frame_dot11_ie_c& ie )

    55     {

    56     if( ie.data_length() < CORE_FRAME_WAPI_IE_MIN_LENGTH )

    57         {

    58         DEBUG( "core_frame_wapi_ie_c::instance() - not a valid IE, too short" );

    59 

    60         return NULL;

    61         }

    62 

    63     core_frame_wapi_ie_c* instance = new core_frame_wapi_ie_c(

    64         ie.data_length(),

    65         ie.data(),

    66         0 );

    67     if( !instance )

    68         {

    69         DEBUG( "core_frame_wapi_ie_c::instance() - unable to create an instance" );

    70 

    71         return NULL;

    72         }

    73     

    74     return instance;

    75     }

    76 

    77 // ---------------------------------------------------------------------------

    78 // ---------------------------------------------------------------------------

    79 //

    80 core_frame_wapi_ie_c* core_frame_wapi_ie_c::instance(

    81     core_cipher_suite_e group_cipher,

    82     core_cipher_suite_e pairwise_cipher,

    83     core_key_management_e key_management,

    84     u16_t capability,

    85     u16_t bkid_length,

    86     const u8_t* bkid_data )

    87     {

    88     const u8_t max_length = CORE_FRAME_WAPI_IE_MIN_LENGTH +

    89         CORE_FRAME_WAPI_IE_BKID_COUNT_SIZE + bkid_length;

    90 

    91     u8_t* buffer = new u8_t[max_length];

    92     if( !buffer )

    93         {

    94         DEBUG( "core_frame_wapi_ie_c::instance() - unable create the internal buffer" );

    95         return NULL;

    96         }

    97 

    98     core_frame_wapi_ie_c* instance =

    99         new core_frame_wapi_ie_c( 0, buffer, max_length );

   100     if( !instance )

   101         {

   102         DEBUG( "core_frame_wapi_ie_c::instance() - unable to create an instance" );

   103         delete[] buffer;

   104 

   105         return NULL;

   106         }

   107 

   108     instance->generate(

   109         group_cipher,

   110         pairwise_cipher,

   111         key_management,

   112         capability,

   113         bkid_length,

   114         bkid_data );

   115 

   116     return instance;

   117     }

   118 

   119 // ---------------------------------------------------------------------------

   120 // ---------------------------------------------------------------------------

   121 //       

   122 core_frame_wapi_ie_c::~core_frame_wapi_ie_c()

   123     {

   124     DEBUG( "core_frame_wapi_ie_c::~core_frame_wapi_ie_c()" );   

   125     }

   126 

   127 // ---------------------------------------------------------------------------

   128 // ---------------------------------------------------------------------------

   129 //

   130 u8_t core_frame_wapi_ie_c::group_cipher_suite() const

   131     {

   132     u8_t cipher_offset(

   133         group_cipher_offset() );

   134     u32_t offset_end(

   135         cipher_offset +

   136         CORE_FRAME_WAPI_IE_CIPHER_OUI_LENGTH );

   137     if( !cipher_offset ||

   138         offset_end > data_length() )

   139         {

   140         DEBUG( "core_frame_wapi_ie_c::pairwise_cipher_suites() - cipher_offset points past the end of IE, ignoring" );

   141 

   142         return core_cipher_suite_none;

   143         }

   144 

   145     return cipher_oui_to_enum(

   146         data_m + cipher_offset );

   147     }

   148 

   149 // ---------------------------------------------------------------------------

   150 // ---------------------------------------------------------------------------

   151 //

   152 u8_t core_frame_wapi_ie_c::pairwise_cipher_suites() const

   153     {

   154     u8_t suites( 0 );

   155     u8_t pairwise_cipher_offset(

   156         pairwise_cipher_count_offset() );

   157     if( !pairwise_cipher_offset )

   158         {

   159         DEBUG( "core_frame_wapi_ie_c::pairwise_cipher_suites() - pairwise_cipher_offset points past the end of IE, ignoring" );

   160         

   161         return core_cipher_suite_none;

   162         }

   163 

   164     u16_t pairwise_cipher_count = core_tools_c::get_u16(

   165         data_m,

   166         pairwise_cipher_offset );

   167 

   168     DEBUG1( "core_frame_wapi_ie_c::pairwise_cipher_suites() - pairwise_cipher_count = %u",

   169         pairwise_cipher_count );

   170 

   171     u32_t offset_end(

   172         pairwise_cipher_offset +

   173         CORE_FRAME_WAPI_IE_CIPHER_COUNT_SIZE +

   174         ( pairwise_cipher_count * CORE_FRAME_WAPI_IE_CIPHER_OUI_LENGTH ) );

   175     if( offset_end > data_length() )

   176         {

   177         DEBUG( "core_frame_wapi_ie_c::pairwise_cipher_suites() - pairwise_cipher_count points past the end of IE, ignoring" );

   178 

   179         return core_cipher_suite_none;

   180         }

   181 

   182     while( pairwise_cipher_count-- )

   183         {

   184         suites += cipher_oui_to_enum(

   185             data_m + pairwise_cipher_offset +

   186             CORE_FRAME_WAPI_IE_CIPHER_COUNT_SIZE +

   187             ( pairwise_cipher_count * CORE_FRAME_WAPI_IE_CIPHER_OUI_LENGTH ) );

   188         }

   189 

   190     return suites;

   191     }

   192 

   193 // ---------------------------------------------------------------------------

   194 // ---------------------------------------------------------------------------

   195 //

   196 u8_t core_frame_wapi_ie_c::key_management_suites() const

   197     {

   198     u8_t suites( 0 );

   199     u16_t key_management_suite_count = core_tools_c::get_u16(

   200         data_m, CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_OFFSET );

   201     u32_t offset_end(

   202         CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_OFFSET +

   203         CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_SIZE +

   204         ( key_management_suite_count * CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_OUI_LENGTH ) );

   205     if( offset_end > data_length() )

   206         {

   207         DEBUG( "core_frame_wapi_ie_c::key_management_suites() - key_management_suite_count points past the end of IE, ignoring" );

   208 

   209         return core_key_management_none;

   210         }

   211 

   212     DEBUG1( "core_frame_wapi_ie_c::key_management_suites() - key_management_suite_count = %u",

   213         key_management_suite_count );

   214 

   215     while( key_management_suite_count-- )

   216         {

   217         suites += key_management_oui_to_enum(

   218             data_m + CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_OFFSET +

   219             CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_SIZE +

   220             ( key_management_suite_count * CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_OUI_LENGTH ) );

   221         }

   222 

   223     return suites;

   224     }

   225 

   226 // -----------------------------------------------------------------------------

   227 // -----------------------------------------------------------------------------

   228 //

   229 u8_t core_frame_wapi_ie_c::pairwise_cipher_count_offset() const

   230     {

   231     u16_t key_management_suite_count = core_tools_c::get_u16(

   232         data_m,

   233         CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_OFFSET );

   234     u32_t offset_end(

   235         CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_OFFSET +

   236         CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT_SIZE +

   237         ( key_management_suite_count * CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_OUI_LENGTH ) );

   238     if( offset_end > data_length() )

   239         {

   240         return 0;

   241         }

   242 

   243     return offset_end;

   244     }

   245 

   246 // -----------------------------------------------------------------------------

   247 // -----------------------------------------------------------------------------

   248 //

   249 u8_t core_frame_wapi_ie_c::group_cipher_offset() const

   250     {

   251     u8_t pairwise_cipher_offset(

   252         pairwise_cipher_count_offset() );

   253     if( !pairwise_cipher_offset )

   254         {

   255         return 0;

   256         }

   257 

   258     u16_t pairwise_cipher_count = core_tools_c::get_u16(

   259         data_m,

   260         pairwise_cipher_offset );

   261     u32_t offset_end(

   262         pairwise_cipher_offset +

   263         CORE_FRAME_WAPI_IE_CIPHER_COUNT_SIZE +

   264         ( pairwise_cipher_count * CORE_FRAME_WAPI_IE_CIPHER_OUI_LENGTH ) );

   265     if( offset_end > data_length() )

   266         {

   267         return 0;

   268         }

   269 

   270     return offset_end;

   271     }

   272 

   273 // -----------------------------------------------------------------------------

   274 // -----------------------------------------------------------------------------

   275 //

   276 core_cipher_suite_e core_frame_wapi_ie_c::cipher_oui_to_enum(

   277     const u8_t* oui ) const

   278     {

   279     if( core_tools_c::compare(

   280         oui,

   281         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH,

   282         &CORE_FRAME_WAPI_IE_OUI_PREFIX[0],

   283         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH ) )

   284         {

   285         DEBUG( "core_frame_wapi_ie_c::cipher_oui_to_enum() - unknown cipher suite" );

   286         return core_cipher_suite_none;

   287         }

   288 

   289     switch( *(oui + CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH) )

   290         {

   291         case CORE_FRAME_WAPI_IE_CIPHER_ID_WPI:

   292             return core_cipher_suite_wpi;

   293         default:

   294             return core_cipher_suite_none;

   295         }

   296     }

   297 

   298 // -----------------------------------------------------------------------------

   299 // -----------------------------------------------------------------------------

   300 //    

   301 core_key_management_e core_frame_wapi_ie_c::key_management_oui_to_enum(

   302     const u8_t* oui ) const

   303     {

   304     if( core_tools_c::compare(

   305         oui,

   306         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH,

   307         &CORE_FRAME_WAPI_IE_OUI_PREFIX[0],

   308         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH ) )

   309         {

   310         DEBUG( "core_frame_wapi_ie_c::key_management_oui_to_enum() - unknown key management suite" );

   311         return core_key_management_none;    

   312         }

   313 

   314     switch( *(oui + CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH) )

   315         {

   316         case CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_CERTIFICATE:

   317             DEBUG( "core_frame_wapi_ie_c::key_management_oui_to_enum() - core_key_management_wapi_certificate" );

   318             return core_key_management_wapi_certificate;

   319         case CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_PSK:

   320             DEBUG( "core_frame_wapi_ie_c::key_management_oui_to_enum() - core_key_management_wapi_psk" );

   321             return core_key_management_wapi_psk;

   322         default:

   323             DEBUG( "core_frame_wapi_ie_c::key_management_oui_to_enum() - core_key_management_none" );

   324             return core_key_management_none;

   325         }

   326     }

   327 

   328 // -----------------------------------------------------------------------------

   329 // -----------------------------------------------------------------------------

   330 //

   331 u8_t core_frame_wapi_ie_c::get_raw_group_cipher(

   332     core_cipher_suite_e cipher ) const

   333     {

   334     switch( cipher )

   335         {        

   336         case core_cipher_suite_wpi:

   337             DEBUG( "core_frame_wapi_ie_c::get_raw_group_cipher() - core_cipher_suite_wpi" );

   338             return CORE_FRAME_WAPI_IE_CIPHER_ID_WPI;

   339         default:

   340             DEBUG( "core_frame_wapi_ie_c::get_raw_group_cipher() - core_cipher_suite_none" );

   341             return CORE_FRAME_WAPI_IE_CIPHER_ID_NONE;

   342         }

   343     }

   344 

   345 // -----------------------------------------------------------------------------

   346 // -----------------------------------------------------------------------------

   347 //

   348 u8_t core_frame_wapi_ie_c::get_raw_pairwise_cipher(

   349     core_cipher_suite_e cipher ) const

   350     {

   351     switch( cipher )

   352         {        

   353         case core_cipher_suite_wpi:

   354             DEBUG( "core_frame_wapi_ie_c::get_raw_pairwise_cipher() - core_cipher_suite_wpi" );

   355             return CORE_FRAME_WAPI_IE_CIPHER_ID_WPI;

   356         default:

   357             DEBUG( "core_frame_wapi_ie_c::get_raw_pairwise_cipher() - core_cipher_suite_none" );

   358             return CORE_FRAME_WAPI_IE_CIPHER_ID_NONE;

   359         }

   360     }

   361 

   362 // -----------------------------------------------------------------------------

   363 // -----------------------------------------------------------------------------

   364 //

   365 u8_t core_frame_wapi_ie_c::get_raw_key_management(

   366     core_key_management_e key_management ) const

   367     {

   368     switch( key_management )

   369         {        

   370         case core_key_management_wapi_certificate:

   371             DEBUG( "core_frame_wapi_ie_c::get_raw_key_management() - core_key_management_wapi_certificate" );

   372             return CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_CERTIFICATE;

   373         case core_key_management_wapi_psk:

   374             DEBUG( "core_frame_wapi_ie_c::get_raw_key_management() - core_key_management_wapi_psk" );

   375             return CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_PSK;

   376         default:

   377             DEBUG( "core_frame_wapi_ie_c::get_raw_key_management() - core_key_management_none" );

   378             return CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_ID_NONE;

   379         }

   380     }

   381 

   382 // ---------------------------------------------------------------------------

   383 // ---------------------------------------------------------------------------

   384 //

   385 void core_frame_wapi_ie_c::generate(

   386     core_cipher_suite_e group_cipher,

   387     core_cipher_suite_e pairwise_cipher,

   388     core_key_management_e key_management,

   389     u16_t capability,

   390     u16_t bkid_length,

   391     const u8_t* bkid_data)

   392     {

   393     ASSERT( !data_length_m );

   394     ASSERT( max_data_length_m );   

   395 

   396     core_frame_dot11_ie_c::generate(

   397         core_frame_dot11_ie_element_id_wapi );

   398 

   399     // Version field

   400     core_tools_c::append_u16(

   401         data_m,

   402         data_length_m,

   403         CORE_FRAME_WAPI_IE_VERSION );

   404 

   405     // Key Management Suite Count field

   406     core_tools_c::append_u16(

   407         data_m,

   408         data_length_m,

   409         CORE_FRAME_WAPI_IE_KEY_MANAGEMENT_COUNT );

   410 

   411     // Key Management Suite List field

   412     core_tools_c::copy(

   413         &data_m[data_length_m],

   414         &CORE_FRAME_WAPI_IE_OUI_PREFIX[0],

   415         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH );

   416     data_length_m += CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH;

   417     data_m[data_length_m++] = get_raw_key_management( key_management );

   418 

   419     // Pairwise Cipher Suite Count field

   420     core_tools_c::append_u16(

   421         data_m,

   422         data_length_m,

   423         CORE_FRAME_WAPI_IE_PAIRWISE_SUITE_COUNT );

   424 

   425     // Pairwise Cipher Suite List field

   426     core_tools_c::copy(

   427         &data_m[data_length_m],

   428         &CORE_FRAME_WAPI_IE_OUI_PREFIX[0],

   429         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH );

   430     data_length_m += CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH;

   431     data_m[data_length_m++] = get_raw_pairwise_cipher( pairwise_cipher );

   432     

   433     // Group Cipher Suite field

   434     core_tools_c::copy(

   435         &data_m[data_length_m],

   436         &CORE_FRAME_WAPI_IE_OUI_PREFIX[0],

   437         CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH );

   438     data_length_m += CORE_FRAME_WAPI_IE_OUI_PREFIX_LENGTH;

   439     data_m[data_length_m++] = get_raw_group_cipher( group_cipher );

   440 

   441     // Capability information

   442     core_tools_c::append_u16(

   443         data_m,

   444         data_length_m,

   445         capability );

   446 

   447     if( bkid_data &&

   448         bkid_length == CORE_FRAME_WAPI_IE_BKID_LENGTH )

   449         {

   450         DEBUG( "core_frame_wapi_ie_c::core_frame_wapi_ie_c() - adding BKID" );

   451 

   452         // BKID Count field

   453         core_tools_c::append_u16(

   454             data_m,

   455             data_length_m,

   456             CORE_FRAME_WAPI_IE_BKID_COUNT );

   457 

   458         // BKID List field

   459         core_tools_c::copy(

   460             &data_m[data_length_m],

   461             &bkid_data[0],

   462             CORE_FRAME_WAPI_IE_BKID_LENGTH );

   463         data_length_m += CORE_FRAME_WAPI_IE_BKID_LENGTH;

   464         }

   465     else

   466         {

   467         // BKID Count field

   468         core_tools_c::append_u16(

   469             data_m,

   470             data_length_m,

   471             0 );        

   472         }

   473 

   474     set_length( data_length_m );

   475     }

   476 

   477 // ---------------------------------------------------------------------------

   478 // ---------------------------------------------------------------------------

   479 //

   480 core_frame_wapi_ie_c::core_frame_wapi_ie_c(

   481     u16_t data_length,

   482     const u8_t* data,

   483     u16_t max_data_length ) :    

   484     core_frame_dot11_ie_c( data_length, data, max_data_length )

   485     {

   486     DEBUG( "core_frame_wapi_ie_c::core_frame_wapi_ie_c()" );   

   487     }