Remote Access Control

createtxhex.cpp

Go to the documentation of this file.

// This file has been prepared for Doxygen automatic documentation generation.
#include "hexfile.h"
#include <sstream>
#include <iomanip>
#include <string>
#include <stdexcept>
#include <vector>
#include <fstream>
#include <algorithm>



class ParameterParser
{
private:
        std::string m_filename; 
        size_t m_keySize; 
        size_t m_serialNoSize; 
        size_t m_counterSize; 
        std::vector< byte > m_sharedKey; 
        std::vector< byte > m_secretKey; 
        std::vector< byte > m_serialNo; 
        std::vector< byte > m_counterValue; 

        std::vector< byte > ParseHexString( const std::string & hexString ) const;
        std::string CreateHexString( const std::vector< byte > & byteVector ) const;

public:
        ParameterParser( size_t argc, const char * * argv );
        ~ParameterParser() {}

        //
        // Query methods.
        // 
        const std::string & GetFilename() const { return m_filename; }
        size_t GetKeySize() const { return m_keySize; }
        size_t GetSerialNoSize() const { return m_serialNoSize; }
        size_t GetCounterSize() const { return m_counterSize; }
        const std::vector< byte > & GetSharedKey() const { return m_sharedKey; }
        const std::vector< byte > & GetSecretKey() const { return m_secretKey; }
        const std::vector< byte > & GetSerialNo() const { return m_serialNo; }
        const std::vector< byte > & GetCounterValue() const { return m_counterValue; }

        std::string GetSharedKeyString() const { return CreateHexString( GetSharedKey() ); }
        std::string GetSecretKeyString() const { return CreateHexString( GetSecretKey() ); }
        std::string GetSerialNoString() const { return CreateHexString( GetSerialNo() ); }
        std::string GetCounterValueString() const { return CreateHexString( GetCounterValue() ); }
};



std::vector< byte > ParameterParser::ParseHexString( const std::string & hexString ) const
{
        // String must be even number of hex digits.
        if( hexString.size() % 2 != 0 ) {
                throw std::runtime_error( "Hex string does not have even character count" );
        }

        //
        // Parse hex digit pairs and insert into byte vector.
        // 
        std::vector< byte > bytes;
        for( size_t idx = 0; idx < hexString.size(); idx += 2 ) {
                std::istringstream iss( hexString.substr( idx, 2 ) );
                byte data;
                iss >> std::hex >> data;
                if( !iss ) {
                        throw std::runtime_error( "Error parsing hex string \"" + hexString + "\"" );
                }
                bytes.push_back( data );
        }
        return bytes;
}



std::string ParameterParser::CreateHexString( const std::vector< byte > & byteVector ) const
{
        std::ostringstream oss;
        oss << std::setfill('0') << std::hex;

        // Add all byte last byte with spaces in between.
        for( size_t idx = 0; idx < byteVector.size() - 1; ++idx ) {
                oss << std::setw(2) << byteVector.at( idx ) << ' ';
        }

        // Add last byte.
        if( byteVector.size() > 0 ) {
                oss << std::setw(2) << byteVector.at( byteVector.size()-1 );
        }

        return oss.str();
}



ParameterParser::ParameterParser( size_t argc, const char * * argv )
{
        // Check that argument count is valid.
        if( argc != 9 ) {
                std::cout << "Parameters:\n"
                        "  filename     - Filename for resulting Intel HEX file\n"
                        "  keysize      - Size in bits of the AES secret and shared keys (128, 192 or 256)\n"
                        "  serialnosize - Size in bytes of the serial number (1, 2 or 4)\n"
                        "  countersize  - Size in bytes of the sequential counter (1, 2 or 4)\n"
                        "  sharedkey    - Hex representation of the shared key (32, 48 or 64 digits)\n"
                        "  secretkey    - Hex representation of the secret key (32, 48 or 64 digits)\n"
                        "  serialno     - Hex representation of the serial number (2, 4 or 8 digits)\n"
                        "  countervalue - Hex representation of the current counter value (2, 4 or 8 digits)\n"
                        << std::endl;
                throw std::runtime_error( "Not exactly 8 parameters" );
        }

        //
        // Create strings or string streams from argument character arrays.
        // 
        std::string arg1( argv[1] ); // Filename
        std::istringstream arg2( argv[2] ); // Key size
        std::istringstream arg3( argv[3] ); // Serial no size
        std::istringstream arg4( argv[4] ); // Counter size
        std::string arg5( argv[5] ); // Shared key
        std::string arg6( argv[6] ); // Secret key
        std::string arg7( argv[7] ); // Serial number
        std::string arg8( argv[8] ); // Counter Value

        //
        // Copy string arguments and parse non-string arguments.
        // 
        m_filename = arg1;
        
        arg2 >> m_keySize;
        if( !arg2 ) {
                throw std::runtime_error( "Error parsing key size argument" );
        }
        
        arg3 >> m_serialNoSize;
        if( !arg3 ) {
                throw std::runtime_error( "Error parsing serial no size argument" );
        }
        
        arg4 >> m_counterSize;
        if( !arg4 ) {
                throw std::runtime_error( "Error parsing counter size argument" );
        }
        
        m_sharedKey = ParseHexString( arg5 );
        m_secretKey = ParseHexString( arg6 );
        m_serialNo = ParseHexString( arg7 );
        m_counterValue = ParseHexString( arg8 );
        
        //
        // Check argument validity.
        // 
        if( m_keySize != 128 && m_keySize != 192 && m_keySize != 256 ) {
                throw std::runtime_error( "Key size is not 128, 192 or 256 bits" );
        }

        if( m_serialNoSize != 1 && m_serialNoSize != 2 && m_serialNoSize != 4 ) {
                throw std::runtime_error( "Serial no is not 1, 2 or 4 bytes" );
        }

        if( m_counterSize != 1 && m_counterSize != 2 && m_counterSize != 4 ) {
                throw std::runtime_error( "Counter is not 1, 2 or 4 bytes" );
        }

        if( m_sharedKey.size() != m_keySize / 8 ) {
                throw std::runtime_error( "Shared key has invalid length" );
        }

        if( m_secretKey.size() != m_keySize / 8 ) {
                throw std::runtime_error( "Secret key has invalid length" );
        }

        if( m_serialNo.size() != m_serialNoSize ) {
                throw std::runtime_error( "Serial number has invalid length" );
        }

        if( m_counterValue.size() != m_counterSize ) {
                throw std::runtime_error( "Counter value has invalid length" );
        }
}



void CreateHEXFile( const ParameterParser & parser )
{
        HEXFile hexData;
        std::ofstream outFile( parser.GetFilename().c_str() );

        // Prepare serial number bytes.
        HEXRecord serialNo;
        std::vector< byte > serialNoReversed = parser.GetSerialNo();
        std::reverse( serialNoReversed.begin(), serialNoReversed.end() );
        serialNo << serialNoReversed;

        // Prepare counter value bytes.
        HEXRecord counterValue;
        std::vector< byte > counterValueReversed = parser.GetCounterValue();
        std::reverse( counterValueReversed.begin(), counterValueReversed.end() );
        counterValue << counterValueReversed;

        // Prepare secret key bytes.
        HEXRecord secretKey;
        secretKey << parser.GetSecretKey();

        // Prepare shared key bytes.
        HEXRecord sharedKey;
        sharedKey << parser.GetSharedKey();

        // Add records to HEX file.
        hexData << serialNo << counterValue << secretKey << sharedKey;

        // Write to disk.
        outFile << hexData;
}



int main( size_t argc, const char * * argv )
{
        try {
                const std::string endian( " (Byte order reversed in HEX file)" );
                ParameterParser parser( argc, argv );
                std::cout << "Filename      : " << parser.GetFilename() << std::endl
                        << "Key size      : " << parser.GetKeySize() << std::endl
                        << "Serial no size: " << parser.GetSerialNoSize() << std::endl
                        << "Counter size  : " << parser.GetCounterSize() << std::endl
                        << "Shared key    : " << parser.GetSharedKeyString() << std::endl
                        << "Secret key    : " << parser.GetSecretKeyString() << std::endl
                        << "Serial no     : " << parser.GetSerialNoString() << endian << std::endl
                        << "Counter value : " << parser.GetCounterValueString() << endian << std::endl;

                CreateHEXFile( parser );
                std::cout << std::endl << parser.GetFilename() << " created!" << std::endl;
        
        } catch( const std::exception & e ) {
                std::cout << "Error: " << e.what() << std::endl;
        } catch(...) {
                std::cout << "Unknown error" << std::endl;
        }
}