campo-sirio/ba/ba1500.cpp

#include <applicat.h>
#include <date.h>
#include <modaut.h>
#include <msksheet.h>
#include <prefix.h>
#include <utility.h>
#include <urldefid.h>

#include <hlapi_c.h>

#include "ba1.h"
#include "ba1500.h"
#include "ba1500a.h"

#define USERADR    26952
#define AGAADR     26953
#define PRASSIADR  26954
#define PROCOMADR  26956
#define K1         0x4500
#define LBYTEMASK  0x00FF
#define UBYTEMASK  0xFF00

#define  BITTEST(w,p) (((w) & (0x0001 << (p))) != 0)
#define  BITSET(w,p,v)  ((v) ? ((w) |= (0x0001 << (p))) : ((w) &= (~(0x0001 << (p)))))

enum KeyType { _user_key, _aga_key, _prassi_key, _procom_key};

class TDongle : public TObject
{ 
  word _serno;                
  KeyType _type;
  word _eprom[64];
  
#if XVT_OS == XVT_OS_SCOUNIX
  word _port;
#endif  

  TBit_array _module;
  bool _dirty;
  
protected:
  bool already_programmed() const;
  bool write_octect(word reg, word data[4]) const;
  
public:        
  bool login();                  
  bool logout();

  word number() const { return _serno; }
  bool ok() const { return _serno != 0xFFFF; }
  
  void garble(word data[4]) const;

  KeyType type() const { return _type; }
  
  bool active(word module) const { return _module[module]; }
  void activate(word module, bool on = TRUE) { _module.set(module, on); _dirty = TRUE; }
  void deactivate(word module) { activate(module, FALSE); }
  
  bool dirty() const { return _dirty; }
  bool burn();
  
  TDongle();
  virtual ~TDongle() { logout(); }
};
           
TDongle::TDongle() 
       : _type(_user_key), _serno(0xFFFF), _dirty(FALSE)
{
  memset(_eprom, 0, sizeof(_eprom));
}  

void TDongle::garble(word k[4]) const
{
#if XVT_OS == XVT_OS_SCOUNIX
  INT_OFF();
  HL_ON(_port, ModAd);
  K_EYE(_port, k, HLBLOCK);
  HL_OFF(_port);
  INT_ON();
#else
  HL_CODE(EYECAST k, 1);
#endif
}

bool TDongle::already_programmed() const
{
  word data[4];
  memcpy(data, &_eprom[60], sizeof(data));
  garble(data);
  
  if (data[0] != 0xFACE)
    return FALSE;
    
  if (data[1] != _serno)  
    return FALSE;
  
  const TDate today(TODAY);
  const long& giulio = (const long&)data[2];
  const long yyyymmdd = today.julian2date(giulio);
  const TDate d(yyyymmdd);
  if (d.year() < 1997 || d.year() > 2997)
    return FALSE;
    
  return TRUE;  
}
           
bool TDongle::login()
{
  bool ok = TRUE;
  _type = _user_key;

#if XVT_OS == XVT_OS_SCOUNIX
  if (Hl_Port(AGAADR) != 0)
    _type = _aga_key;
  else
    if (Hl_Port(PRASSIADR) != 0)
      _type = _prassi_key;
    else
      if (Hl_Port(PROCOMADR) != 0)
        _type = _prcom_key;
  _port = Hl_Port(USERADR);
#else
  HL_LOGOUT();
  if (HL_LOGIN(AGAADR, DONT_CARE, REFKEY, VERKEY) == STATUS_OK) 
    _type = _aga_key;
  else
  {
    HL_LOGOUT();
    if (HL_LOGIN(PRASSIADR, DONT_CARE, REFKEY, VERKEY) == STATUS_OK)
      _type = _prassi_key;
    else
    {
      HL_LOGOUT();
      if (HL_LOGIN(PROCOMADR, DONT_CARE, REFKEY, VERKEY) == STATUS_OK)
        _type = _procom_key;
    }
  }
  HL_LOGOUT();
  ok = HL_LOGIN(USERADR, DONT_CARE, REFKEY, VERKEY) == STATUS_OK;
  
  if (ok)
  {
    HL_READBL((char*)_eprom);

    word data[4];
    memcpy(data, _eprom, sizeof(data));
    garble(data);
    
    if (data[0] == 0xFAE8)
      _serno = data[1];
    else
    {
      if (_type == _user_key)
        ok = FALSE;  
      else
        _serno = 0;  
    }  
  }  
  
  if (ok) 
  {
    if (_serno > 0)
    {  
      _module.reset();    
      _module.set(0, TRUE);
                          
      const int last_word = already_programmed() ? 12 : 4;                    
      for (int i = 0; i < last_word; i += 4)
      {
        word data[4];
        memcpy(data, &_eprom[48+i], sizeof(data));
        garble(data);
        if (data[3] == _serno) // Validate block
        {
          for (int j = 0; j < 3; j++)
          {
            word parola = data[j] ^ _serno;
            for (int b = 15; b >= 0; b--)
            {
              if (BITTEST(parola, b))             
              {
                const word bit = i * 12 + j * 16 + b;
                _module.set(bit);
              }  
            }  
          }
        }
        else
          break;
      }
    }  
    else
    {                   
      _module.set(MAX_AUT-1);    
      _module.set();    
    }  
  }  
#endif

  return ok;
}

bool TDongle::logout()
{
  HL_LOGOUT();
  _serno = 0xFFFF;
  return TRUE;
}

bool TDongle::write_octect(word reg, word k[4]) const
{
  int err = STATUS_OK;
  for (word r = 0; r < 4; r++)
  {           
    const word address = reg+r;
    err = HL_WRITE(address, k[r]);
    if (err != STATUS_OK)                                     
    {
      error_box("Errore di scrittura sul registro %u", address);
      break;
    }  
#ifdef DBG
    word test;
    HL_READ(address, (int*)&test);
    if (test != k[r])
      error_box("Errore di scrittura sul registro %u", address);
#endif      
  }  
  return err == STATUS_OK;
}

bool TDongle::burn()
{
  if (!dirty() || _serno == 0 || _serno == 0xFFFF)
    return FALSE;
    
  word data[4];

  const TDate today(TODAY);   
  const bool already = already_programmed();
  if (already)  
  {       
    memcpy(data, &_eprom[60], sizeof(data));
    garble(data);                         
    if (data[0] != 0xFACE)
      return error_box("Checksum error.");
    if (data[1] != _serno)
      return error_box("Bad serial number.");
    const long& val = (const long&)data[2];
    const long yyyymmdd = today.julian2date(val);
    const TDate date(yyyymmdd);
    if (date > today)
      return error_box("Too late sir: key has already expired!");
  }
  
  data[0] = 0xFACE;
  data[1] = _serno;
  long& val = (long&)data[2];
  val = today.date2julian();
  garble(data);
  write_octect(60, data);
  
  word module = 0;
  for (int octect = 0; octect < 3; octect++)  
  {                                       
    for(int parola = 0; parola < 3; parola++)  
    {        
      word& p = data[parola];
      p = 0;
      for (int bit = 0; bit < 16; bit++)
      {          
        if (active(module))
          BITSET(p, bit, TRUE);
        module++;
      }
      p ^= _serno;
    }
    data[3] = _serno;
    garble(data);
    write_octect(48 + 4*octect, data);
  }
  
  _dirty = FALSE; 
  return TRUE;
}

///////////////////////////////////////////////////////////

TInformazione_moduli::TInformazione_moduli()
{
  int mod = 0;
  TString s(256);
  TToken_string t;
  TString_array descs;
  
  _unassigned_modules = 0;
  ifstream  in("prassi.aut");
  while (!in.eof() && in.good())
  {
    in.getline(s.get_buffer(256), s.size());
    s.trim();
    if (s.empty()) 
      break;
    const int l = s.len();
    if (l > 2)
    {
//      t = format("%-40s", (const char*)s.right(l-3));
      t = format("%-40s", (const char*)s.mid(3));
      t.add(s.left(2));
    }
    else
    {
      t = " "; t.add(" ");
      _unassigned_modules++;
    }
    t.add(mod++); 
    s = t.get(0);
    descs.add(s);
    s.upper();
    t.add(s, 0);
    _infos.add(t);
  }
  
  if (in.bad() && !in.eof())
    error_box("Si e' verificato un errore leggendo il file di descrizione moduli.");
  
  _infos.sort();
  for (int i=0;i<mod;i++)
  {
    TToken_string& riga = _infos.row(i);
    const int mod = riga.get_int(2);
    _index[mod] = i;         
    s = descs.row(mod).get(0);
    riga.add(s, 0);
  }
}

const char * TInformazione_moduli::get_description_by_order(int index)
{ 
  if (index >= 0 && index < _infos.items())
    return _infos.row(index).get(0);
  else
    return "";
}

const char * TInformazione_moduli::get_name_by_order(int index)
{ 
  if (index >= 0 && index < _infos.items())
    return _infos.row(index).get(1);
  else 
    return "";
}

int TInformazione_moduli::get_module_by_order(int index)
{
  if (index >= 0 && index < _infos.items())
    return _infos.row(index).get_int(2);
  else
    return -1;
}

const char * TInformazione_moduli::get_description(int module)
{ return get_description_by_order(_index[module]); }

const char * TInformazione_moduli::get_name(int module)
{ return get_name_by_order(_index[module]); }

int TInformazione_moduli::get_index(int module)
{ return _index[module]; }

///////////////////////////////////////////////////////////
// 
///////////////////////////////////////////////////////////

class TAttivazione_moduli : public TApplication
{
  TMask* _msk;
  TInformazione_moduli* _im;

  TDongle _dongle;
  word _serno;

protected:
  virtual bool create() ;                         
  virtual bool destroy() ;                        
  virtual bool use_files() const { return FALSE; }
  virtual bool menu(MENU_TAG);
  
  void garble(word k[4]) const;
  void garble(word n, TString& str) const;
  word& serno() { return _serno; }
  
  void generate_key();
  int build_sheet(bool on = TRUE);
  void build_key_column();
  
  bool burn_dongle();
  
  static void keyext(const TString & s, word * v);
  static void encode_second_key();
  
  static bool user_hnd(TMask_field & f, KEY k);
  static bool serno_hnd(TMask_field & f, KEY k);
  static bool decode_hnd(TMask_field & f, KEY k);
  static bool activate_hnd(TMask_field & f, KEY k);
  static bool k_notify(TSheet_field & f, int r, KEY k);

public:
  TAttivazione_moduli() : _msk(NULL) { }
};


HIDDEN TAttivazione_moduli& app() { return (TAttivazione_moduli &)main_app(); }

int TAttivazione_moduli::build_sheet(bool on)
{
  int nmod = 0;
  TSheet_field& sf = (TSheet_field&)_msk->field(F_MODULI);
  for (int i = 0; i < _im->items(); i++)
  {
    const TFixed_string d(_im->get_description_by_order(i));
    if (d.blank()) 
      continue;
    TToken_string& riga = sf.row(i);
    riga = d; riga.trim();
    const int module = _im->get_module_by_order(i);
    
    const bool ics = module == 0 || (on && _dongle.active(module));
    if (ics)
    {
      riga.add("X");
      if (module != 0) 
        nmod++;
    } 
    else 
      riga.add(" ");
    riga.add(module);
  }
  return nmod;
}

void TAttivazione_moduli::garble(word k[4]) const
{
  _dongle.garble(k);
}

void TAttivazione_moduli::garble(word n, TString& str) const
{
  const TDate today(TODAY);
  const long val = today.date2julian();
  
  word data[4];
  data[0] = word(_msk->get_int(F_SN));
  data[1] = n;
  data[2] = word(val >> 16);
  data[3] = word(val & 0xFFFF);
  garble(data);
  str.format("%04X%04X", data[0], data[1]);
}

void TAttivazione_moduli::build_key_column()
{       
  TSheet_field& sf = (TSheet_field&)_msk->field(F_MODULI);
  sf.enable_column(F_KEY, FALSE);

  TString16 tmp;
  for (int i = sf.items()-1; i >= 0; i--)
  {   
    if (!sf.cell_disabled(i, 1))
    {
      TToken_string& riga = sf.row(i);
      int module = riga.get_int(2);
      garble(module, tmp);
      riga.add(tmp, 3);
    }  
  }
  
  sf.force_update();
}

bool TAttivazione_moduli::burn_dongle()
{   
  bool ok = _dongle.type() == _user_key;
  
  if (ok)
  {
    TString16 str, key;
  
    TSheet_field& sf = (TSheet_field&)_msk->field(F_MODULI);
    for (int i = 0; i < sf.items(); i++)
    {
      TToken_string& riga = sf.row(i);
      key = riga.get(3); key.trim();
      if (key.not_empty())
      {
        const int module = riga.get_int(2);
        garble(module, str);
        if (key == str)
        {
          if (!_dongle.active(module) &&
              yesno_box("Confermare l'attivazione del modulo %d:\n%s", 
                        module, riga.get(0)))
          {         
            _dongle.activate(module);
          }              
        }
        else
        {
          if (_dongle.active(module) &&
              yesno_box("Confermare la disattivazione del modulo %d:\n%s", 
                        module, riga.get(0)))
          {              
            _dongle.deactivate(module);
          }  
        }
      }
    }  
    
    if (_dongle.dirty())
    {
      ok = _dongle.burn();
      if (!ok)
        error_box("Impossibile riprogrammare la chiave");
    }
  }
  
  return ok;  
}

void TAttivazione_moduli::generate_key()
{
#if XVT_OS == XVT_OS_SCOUNIX
  word ud[4];
  INT_OFF();
  HL_ON(_port, USERADR);
  ud[0] = HL_RD(_port, 48);
  ud[1] = HL_RD(_port, 49);
  ud[2] = HL_RD(_port, 50);
  ud[3] = HL_RD(_port, 51);
  HL_OFF(_port);
  INT_ON();
#else
  word ud[4];
  HL_READ(48, (int*)&ud[0]);
  HL_READ(49, (int*)&ud[1]);
  HL_READ(50, (int*)&ud[2]);
  HL_READ(51, (int*)&ud[3]);
#endif
  
  int    nmod;

  _msk->set(F_K2, format("%04X%04X%04X%04X", ud[0], ud[1], ud[2], ud[3]));
  nmod  = build_sheet();
  ud[0] = _dongle.number();
  ud[1] = K1 | (nmod & LBYTEMASK);
  long & l = (long &) ud[2];
  TDate d(TODAY);

  l = d.year()*10000L + d.month()*100L + d.day();
  garble(ud);
  _msk->set(F_K1, format("%04X%04X%04X%04X", ud[0], ud[1], ud[2], ud[3]));
  _msk->set(F_SN, _dongle.number());
  _msk->set(F_DT, d);
}

int hexdigit(char c)
{
  return c >= 'A' ? (c - 'A' + 10) : (c - '0');
}

void TAttivazione_moduli::keyext(const TString& s, word * val)
{
  for (int i = 0 ; i < 4; i++)
  {
    const int off = i * 4;
    word & l = val[i];
    
    l = 0;
    for (int j = 0; j < 4; j++)
      l = l * 16 + hexdigit(s[off + j]);
  }
}

bool TAttivazione_moduli::user_hnd(TMask_field & f, KEY k)
{
  const TString16 k4(f.get());
  if (!f.to_check(k) || k4.empty()) 
    return TRUE;
  TMask & m = f.mask();
  word ud1[4], ud2[4];
  const TString16 k3(m.get(F_K3));
  
  keyext(k3, ud1);
  keyext(k4, ud2);
  
  app().garble(ud1);
  const long & l = (long &) ud1[0];
  TDate d(l), d1(TODAY);

  d.addmonth(3);
  if (d < d1)
    return f.error_box("data non valida");
  if ((ud1[2] & UBYTEMASK) != K1 || ud1[3] != app().serno()) 
    return f.error_box("primo codice errato");
    
  app().garble(ud2);
  for (int i = 0; i < 4; i++) ud2[i] ^= app().serno();
  if (ud2[3] != 0) 
    return f.error_box("secondo codice errato");
  TSheet_field& sf = (TSheet_field&) m.field(F_MODULI);
  const int un = app()._im->unassigned();
  for (i = un; i < MAX_AUT; i++)
  {
    const int af = app()._im->get_module_by_order(i) - 1;
    if (af < 0) continue;
    TToken_string& tt = sf.row(i-un);
    tt.add(BITTEST(ud2[af / 16], af % 16) ? "X" : " ", 1);
  }
  if (k == K_ENTER)
  {
    keyext(k4, ud2);
#if XVT_OS == XVT_OS_SCOUNIX
    word port = app()._dongle.port();
    INT_OFF();
    HL_ON(port, ModAd);
    HL_WR(port, 48, ud2[0]);
    HL_WR(port, 49, ud2[1]);
    HL_WR(port, 50, ud2[2]);
    HL_WR(port, 51, ud2[3]);
    HL_OFF(port);
    INT_ON();
#else
    HL_WRITE(48, ud2[0]);
    HL_WRITE(49, ud2[1]);
    HL_WRITE(50, ud2[2]);
    HL_WRITE(51, ud2[3]);
#endif
  } else
    sf.force_update();
  return TRUE;
}

bool TAttivazione_moduli::serno_hnd(TMask_field& f, KEY k)
{
  if (k == K_TAB && f.focusdirty())
  {
    app().build_key_column();
  }
  return TRUE;
}

void TAttivazione_moduli::encode_second_key()
{
  TMask * m = app()._msk;
  word    ud1[4], ud2[4];
  int     nmod = 0;
  
  for (int i = 0; i < 4; i++) ud2[i] = 0;
  TSheet_field& sf = (TSheet_field&) m->field(F_MODULI);
  const int un = app()._im->unassigned();
  for (i = un; i < MAX_AUT; i++)
  {
    const int af = app()._im->get_module_by_order(i) -1;
    if (af < 0) continue;
    TToken_string& tt = sf.row(i-un);
    if (tt.get(1)[0] == 'X')
    {
      BITSET(ud2[af / 16], af % 16, TRUE);
      nmod++;
    }
  }
  for (i = 0; i < 4; i++) ud2[i] ^= app().serno();

  const TDate d(m->get(F_DT));
  long & l = (long &) ud1[0];
  
  l = d.year()*10000L + d.month()*100L + d.day();
  ud1[2] = K1 | (nmod & UBYTEMASK);
  ud1[3] = app().serno();
  
  app().garble(ud1);
  m->set(F_K3, format("%04X%04X%04X%04X", ud1[0], ud1[1], ud1[2], ud1[3]));

  app().garble(ud2);
  m->set(F_K4, format("%04X%04X%04X%04X", ud2[0], ud2[1], ud2[2], ud2[3]));
}

bool TAttivazione_moduli::decode_hnd(TMask_field & f, KEY k)
{
  const TString16 k2(f.get());
  if (!f.to_check(k) || k2.empty()) 
    return TRUE;
  
  TMask& m = f.mask();
  word ud1[4], ud2[4];
  const TString16 k1(m.get(F_K1));
  
  keyext(k1, ud1);
  keyext(k2, ud2);

  app().garble(ud1);
  long & l = (long &) ud1[2];
  const TDate  d(l);
  app().serno() = ud1[0];
  if ((ud1[1] & UBYTEMASK) != K1)
    return f.error_box("primo codice errato");
  
  app().garble(ud2);
  for (int i = 0; i < 4; i++) ud2[i] ^= app().serno();
  if (ud2[3] != 0)
    return f.error_box("secondo codice errato");
  m.set(F_SN, app().serno());
  m.set(F_DT, d);
  m.set(F_K3,k1);
  m.set(F_K4,k2);
  TSheet_field& sf = (TSheet_field&) m.field(F_MODULI);
  const int un = app()._im->unassigned();
  for (i = un; i < MAX_AUT; i++)
  {
    const int af = app()._im->get_module_by_order(i) -1;
    if (af < 0) continue;
    TToken_string& tt = sf.row(i-un);
    tt.add(BITTEST(ud2[af / 16], af % 16) ? "X" : " ", 1);
  }
  encode_second_key();
  sf.force_update();
  return TRUE;
}

bool TAttivazione_moduli::activate_hnd(TMask_field & f, KEY k)
{
  encode_second_key();
  return TRUE;
}

bool TAttivazione_moduli::k_notify(TSheet_field& f, int r, KEY k)
{
  if (k == K_INS)
    return FALSE;
  return TRUE;
}

bool TAttivazione_moduli::create()
{
  bool ok = _dongle.login();
  if (!ok)
    return FALSE;

  _im = new TInformazione_moduli;
  
  disable_menu_item(M_FILE_NEW);
  disable_menu_item(M_FILE_REVERT);
  disable_menu_item(M_FILE_PG_SETUP);

  _msk = new TMask("ba1500a") ;

  TSheet_field& sf = (TSheet_field&) _msk->field(F_MODULI);
  const int un = _im->unassigned();
  sf.set_notify(k_notify);
  
  switch (_dongle.type())
  {
  case _user_key:
  {
    _msk->disable(F_K1);
    _msk->disable(F_K2);
    _msk->set_handler(F_K4, user_hnd);
    generate_key();
    sf.enable_column(F_ENABLE, FALSE);
    sf.enable_column(F_KEY, serno() != 0);
  }
  break;
  case _prassi_key: 
  {
    const int aut[] = { CMAUT, ATAUT, POAUT, AFAUT, TCAUT, TMAUT, 
                        VEAUT, MGAUT, ORAUT, EFAUT, DBAUT, SVAUT, -1 };
    for (int a = 0; aut[a] >= 0; a++)          
      sf.disable_cell(_im->get_index(aut[a])-un,1);        
  }  
  case _aga_key:
  case _procom_key:
  {
    _msk->set_handler(F_K2, decode_hnd);
    _msk->disable(F_K3);
    _msk->disable(F_K4); 
    
    _msk->set_handler(F_SN, serno_hnd);
    _msk->enable(F_SN);
    
    sf.sheet_mask().field(F_ENABLE).set_handler(activate_hnd);
    build_sheet(FALSE);  
    
    for (int i = un; i < MAX_AUT; i++)
    {
      const int af = _im->get_module_by_order(i);
      const int index = i-un;
      if (af == 0)
        sf.disable_cell(index,1);
      if (_dongle.type() == _procom_key)
        sf.enable_cell(index,1,af>=40 && af<=46);
      else
        if (af>=40 && af<=46)
            sf.disable_cell(index,1);
    }
    
    build_key_column();
  }
  break;
  default:
  break;
  }
  dispatch_e_menu(BAR_ITEM(1));
  return TRUE;
}

bool TAttivazione_moduli::destroy()
{
  if (_msk != NULL) delete _msk;
  if (_im  != NULL) delete _im;
  return TRUE;
}

bool TAttivazione_moduli::menu(MENU_TAG)
{
  KEY res = _msk->run();
  if (res == K_ENTER)
    burn_dongle();

  return FALSE;
}

int ba1500(int argc, char** argv)
{
  // dipende dalla check_parameters fatta in main()
  if (user() == "PRASSI")
  {
    TAttivazione_moduli a ;
    a.run(argc, argv, "Attivazione moduli");
  }
  else 
  {                                                                                    
    error_box("L'utente %s non e' abilitato all'esecuzione di questo programma", (const char*)user());
  }
  return 0;
}