Аутентификация пользователей на Arduino с RFID

#include <SPI.h> //include the SPI bus library
#include <MFRC522.h> //include the RFID reader library

#define SS_PIN 10  //slave select pin
#define RST_PIN 9  //reset pin

#define u1b 2  //Block on a card for user1 byte array
#define u2b 4  //Block on a card for user2 byte array
#define p1b 5  //Block on a card for pass1 byte array
#define p2b 6  //Block on a card for pass2 byte array

MFRC522 mfrc522(SS_PIN, RST_PIN);        // instatiate a MFRC522 reader object.
MFRC522::MIFARE_Key key; //create a MIFARE_Key struct named 'key', which will hold the card information

byte readbackblock[18]; //This array is used for reading out a block. The MIFARE_Read method requires a buffer that is at least 18

String inString = ""; // COM port incoming data buffer

void setup() {
  Serial.begin(9600);        // Initialize serial communications with the PC
  SPI.begin();               // Init SPI bus
  mfrc522.PCD_Init();        // Init MFRC522 card (in case you wonder what PCD means: proximity coupling device)
  // Serial.println("Scan a MIFARE Classic card");

  // Prepare the security key for the read and write functions - all six key bytes are set to 0xFF at chip delivery from the factory
  // Since the cards in the kit are new and the keys were never defined, they are 0xFF
  // if we had a card that was programmed by someone else, we would need to know the key to be able to access it. 
  // This key would then need to be stored in 'key' instead.

  for (byte i = 0; i < 6; i++) {
    key.keyByte[i] = 0xFF; // keyByte is defined in the "MIFARE_Key" 'struct' definition in the .h file of the library
  }
}

void loop() {
  // put your main code here, to run repeatedly:
  // Receive data from com port
  while (Serial.available() > 0) {
    int inChar = Serial.read();

    if (inChar != 'n') {
      inString += (char)inChar;
     } else {
      // New line
      while (!initCard()); // connect to an RFID card
      String Action = inString.substring(0, 3);
      if (Action == "Set") {
        // Write login and pass into the card
        setUserAndPassToCard(inString);
      } else if (Action == "Get") {
        // Read login and pass from the card
        readUserAndPassToCom();
      } else {
        Serial.println(Action);
      }
      
      disconnectCard(); // disconnect RFID card
      inString = "";
    }
  }
}

/// Read blocks with user/pass info and output the to COM port:
/// user1user2@pass1pass2
void readUserAndPassToCom()
{
  readBlockToCom(u1b);
  readBlockToCom(u2b);
  Serial.write("@");
  readBlockToCom(p1b);
  readBlockToCom(p2b);
  Serial.println("");
}

/// Set user/pass info into a card
/// Data: Set@user1@user2@pass1@pass2
/// Data sample: Set@1234567890123456@1234567890123456@1234567890123456@1234567890123456
void setUserAndPassToCard(String Data) {
  // Serial.println(Data);
  byte user1[16], user2[16], pass1[16], pass2[16];

  String user1str = inString.substring(4, 20);
  String user2str = inString.substring(21, 37);
  String pass1str = inString.substring(38, 54);
  String pass2str = inString.substring(55, 71);

  stringToArray(user1str, user1, sizeof(user1));
  stringToArray(user2str, user2, sizeof(user2));
  stringToArray(pass1str, pass1, sizeof(pass1));
  stringToArray(pass2str, pass2, sizeof(pass2));

  writeBlock(u1b, user1); // u1b is the block number, user1 is the block content
  writeBlock(u2b, user2);
  writeBlock(p1b, pass1);
  writeBlock(p2b, pass2);
  
  Serial.println("Done");
}

void stringToArray(String str, byte array[], int arrlength)
{
  for (int j = 0 ; j < arrlength ; j++)
  {
    array[j] =  str.charAt(j);
  }
}

bool initCard()
{
  // Look for new cards (in case you wonder what PICC means: proximity integrated circuit card)
  if ( ! mfrc522.PICC_IsNewCardPresent()) {//if PICC_IsNewCardPresent returns 1, a new card has been found and we continue
    return false; //if it did not find a new card is returns a '0' and we return to the start of the loop
  }

  // Select one of the cards
  if ( ! mfrc522.PICC_ReadCardSerial()) {//if PICC_ReadCardSerial returns 1, the "uid" struct (see MFRC522.h lines 238-45)) contains the ID of the read card.
    return false; //if it returns a '0' something went wrong and we return to the start of the loop
  }
  return true;
}

void disconnectCard()
{
  // Halt PICC
  mfrc522.PICC_HaltA();
  // Stop encryption on PCD
  mfrc522.PCD_StopCrypto1();
}

void readBlockToCom(int number)
{
  readBlock(number, readbackblock);//read the block back
  for (int j = 0 ; j < 16 ; j++) //print the block contents
  {
    Serial.write (readbackblock[j]);//Serial.write() transmits the ASCII numbers as human readable characters to serial monitor
  }
}

int writeBlock(int blockNumber, byte arrayAddress[])
{
  // this makes sure that we only write into data blocks. Every 4th block is a trailer block for the access/security info.
  int largestModulo4Number = blockNumber / 4 * 4;
  int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector
  if (blockNumber > 2 && (blockNumber + 1) % 4 == 0) {
    Serial.print(blockNumber);  //block number is a trailer block (modulo 4); quit and send error code 2
    Serial.println(" is a trailer block:");
    return 2;
  }
  //Serial.print(blockNumber);
  //Serial.println(" is a data block:");

  /*****************************************authentication of the desired block for access***********************************/
  byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
  // byte PCD_Authenticate(byte command, byte blockAddr, MIFARE_Key *key, Uid *uid);
  // this method is used to authenticate a certain block for writing or reading
  // command: See enumerations above -> PICC_CMD_MF_AUTH_KEY_A	= 0x60 (=1100000),		
  // this command performs authentication with Key A
  // blockAddr is the number of the block from 0 to 15.
  // MIFARE_Key *key is a pointer to the MIFARE_Key struct defined above, this struct needs to be defined for each block. 
  // New cards have all A/B= FF FF FF FF FF FF
  // Uid *uid is a pointer to the UID struct that contains the user ID of the card.
  if (status != MFRC522::STATUS_OK) {
    Serial.print("PCD_Authenticate() failed: ");
    Serial.println(mfrc522.GetStatusCodeName(status));
    return 3;//return "3" as error message
  }
  // it appears the authentication needs to be made before every block read/write within a specific sector.
  // If a different sector is being authenticated access to the previous one is lost.

  /*****************************************writing the block***********************************************************/

  status = mfrc522.MIFARE_Write(blockNumber, arrayAddress, 16);
  //valueBlockA is the block number, MIFARE_Write(block number (0-15), byte array containing 16 values, number of bytes in block (=16))
  // status = mfrc522.MIFARE_Write(9, value1Block, 16);
  if (status != MFRC522::STATUS_OK) {
    Serial.print("MIFARE_Write() failed: ");
    Serial.println(mfrc522.GetStatusCodeName(status));
    return 4;//return "4" as error message
  }
  //Serial.println("block was written");
}

int readBlock(int blockNumber, byte arrayAddress[])
{
  int largestModulo4Number = blockNumber / 4 * 4;
  int trailerBlock = largestModulo4Number + 3; //determine trailer block for the sector

  /*****************************************authentication of the desired block for access********************************************/
  byte status = mfrc522.PCD_Authenticate(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid));
  // byte PCD_Authenticate(byte command, byte blockAddr, MIFARE_Key *key, Uid *uid);
  // this method is used to authenticate a certain block for writing or reading
  // command: See enumerations above -> PICC_CMD_MF_AUTH_KEY_A	= 0x60 (=1100000),		
  // this command performs authentication with Key A
  // blockAddr is the number of the block from 0 to 15.
  // MIFARE_Key *key is a pointer to the MIFARE_Key struct defined above, this struct needs to be defined for each block. 
  // New cards have all A/B= FF FF FF FF FF FF
  // Uid *uid is a pointer to the UID struct that contains the user ID of the card.
  if (status != MFRC522::STATUS_OK) {
    Serial.print("PCD_Authenticate() failed (read): ");
    Serial.println(mfrc522.GetStatusCodeName(status));
    return 3;//return "3" as error message
  }
  // it appears the authentication needs to be made before every block read/write within a specific sector.
  // If a different sector is being authenticated access to the previous one is lost.

  /*****************************************reading a block***********************************************************/

  byte buffersize = 18;//we need to define a variable with the read buffer size, since the MIFARE_Read method below needs a pointer to the variable that contains the size...
  status = mfrc522.MIFARE_Read(blockNumber, arrayAddress, &buffersize);//&buffersize is a pointer to the buffersize variable; MIFARE_Read requires a pointer instead of just a number
  if (status != MFRC522::STATUS_OK) {
    Serial.print("MIFARE_read() failed: ");
    Serial.println(mfrc522.GetStatusCodeName(status));
    return 4;//return "4" as error message
  }
}

/// Delegated Authentication with Arduino.
/// Installation steps:<br>
/// 1. Connect arduino (and upload C code from Delegated.ino there)<br>
/// 2. Make this class visible in %SYS namespace (import there or map pckage)<br>
/// 3. Set SerialPort parameter to a correct value and recompile the class<br>
/// 4. Run <example>Do ##class(Arduino.Delegated).InitEncryption(Key, IV)</example>
/// 5. Write encrypted user credentials to RFID card  with SetCredentials<br>
/// 6. Import ZAUTHENTICATE into %SYS<br>
/// 7. Enable Delegated and password auth for relevant services and/or apps
Class Arduino.Delegated [ Abstract ]
{

Parameter SerialPort As %String = "com3";

/// Creates managed encryption key.<br>
/// key - Input key material.
/// Key material 16, 24, or 32 characters long (on Unicode systems, with all character values < 256) is used directly.
/// Otherwise, Password-Based Key Derivation Function #2 (PBKDF2)
/// is used with HMAC-SHA-1,
/// no salt, and one iteration
/// to generate an AES key of the next larger valid size (up to 32 bytes).
/// (See RSA Laboratories Public-Key Cryptography Standards #5 for more information.)
/// <br><br>
/// IV - Initialization vector (optional).
/// If this argument is present it must be 16 characters long (on Unicode systems, with all character values < 256).
/// If this argument is omitted (or is an empty string), a null initialization vector is used.
/// <br>
/// <example>Do ##class(Arduino.Delegated).Init("", "")</example>
ClassMethod Init(Key As %String, IV As %String)
{
	New $Namespace
	Set $Namespace = "%SYS"
	Set ^Arduino("Key")= Key
	Set ^Arduino("IV")= IV
}

/// Send Arduino the command to set credentials on a card to Username/Password (encrypted)
/// <example>Do ##class(Arduino.Delegated).SetCredentials("_SYSTEM", "SYS")</example>
ClassMethod SetCredentials(Username As %String(MAXLEN=15), Password As %String(MAXLEN=15)) As %Status
{
	
	Set Status = $$$OK
	
	Set CipherUsername = ..EncryptText(Username)
	Set CipherPassword = ..EncryptText(Password)
	
	Set User1 = $Extract(CipherUsername, 1, 16)
	
	Set User2 = $Extract(CipherUsername, 17, 32)
	Set User2 = ..AppendToString(User2, , 16)
	
	Set Pass1 = $Extract(CipherPassword, 1, 16)
	
	Set Pass2 = $Extract(CipherPassword, 17, 32)
	Set Pass2 = ..AppendToString(Pass2, , 16)
	
	Set CommandList = $ListBuild("Set", User1, User2, Pass1, Pass2)
	Set Command = $ListToString(CommandList, "@")

	Set Status = ..ExecuteCommand(.Command)
	If (Status = "Done") {
		Set Status = $$$OK
	} Else {
		Set Status = $$$ERROR($$$GeneralError, "SetCredentials failure, received: " _ Status) 
	}
	
	Return Status
}

/// Connect to an Arduino device, receive credentials, decode them and set to Username/Password variables.
/// <example>do ##class(Arduino.Delegated).GetCredentials(.Username, .Password)</example>
ClassMethod GetCredentials(Output Username As %String, Output Password As %String) As %Status
{
	Kill Username, Password
	Set Username = ""
	Set Password = ""
	Set Status = $$$OK
	
	Set Credentials = ..ExecuteCommand("Get")
	If (($L(Credentials) =65) && ($L(Credentials,"@") = 2)) {
		Set CipherUsername = $Piece(Credentials, "@", 1)
		Set CipherPassword = $Piece(Credentials, "@", 2)
		Set CipherUsername = $Extract(CipherUsername, 1, 24) // we need only first 24 characters
		Set CipherPassword = $Extract(CipherPassword, 1, 24)
		Set Username = ..DecryptText(CipherUsername)
		Set Password = ..DecryptText(CipherPassword)
	} Else {
		Set Status = $$$ERROR($$$GeneralError, "GetCredentials failure, received: " _ Credentials) 
	}
	
	Return Status
}

/// Send one line at a time, using common terminating characters (i.e., CR) and receive output
/// Possible comands:<br>
/// <b>Get</b> - reads an RFID card and returns information in a format: user@pass<br>
/// <b>Set@user1@user2@pass1@pass2</b> - sets information on a RFID card 
/// in a format: user@pass (where user = user1@user2)<br>
/// Returns output, produced by Arduino
/// <example>w ##class(Arduino.Delegated).ExecuteCommand("Get")</example>
ClassMethod ExecuteCommand(ByRef Command As %String, SerialPort = {..#SerialPort}) As %String
{
	set x=""
	try {
        //Parameters used to open the serial device:
        //  portstate = " 0801n0" - by byte position:
        //      1: space indicates "don't disconnect the port"
        //      2: 0 indicates "don't use modem control"
        //      3: 8 indicates 8 data bits
        //      4: 0 indicates no parity
        //      5: 1 indicates one stop bit
        //      6: n indicates that flow control is disabled
        //      7: 0 indicates disable DTR
        //  /BAUD=9600 determines the baud rate, of course.
        open SerialPort:(:::" 0801n0":/BAUD=9600)
        set old = $io //Keep track of the original device
        use SerialPort

	write $char(10)
        hang 1
        write Command _ $Char(10)
        
        read x //Read until a termination character is reached
        use old
        close SerialPort       
    } catch ex {
        close SerialPort
        w $System.Status.GetErrorText(ex.AsStatus())
    }
    
    return x
}

/// Get key to encode/decode via EncryptText/DecryptText
ClassMethod GetKey() [ CodeMode = expression ]
{
$Get(^Arduino("Key"))
}

/// Get IV to encode/decode via EncryptText/DecryptText
ClassMethod GetIV() [ CodeMode = expression ]
{
$Get(^Arduino("IV"))
}

/// Encrypt PlainText with AESCBCEncrypt
/// <example>Write ##class(Arduino.Delegated).EncryptText("string")</example>
ClassMethod EncryptText(PlainText As %String) As %String
{
	
	Set Text=$ZConvert(PlainText,"O","UTF8")
	Set Text=$System.Encryption.AESCBCEncrypt(Text, ..GetKey(), ..GetIV())
	Set Ciphertext=$System.Encryption.Base64Encode(Text)
	Return Ciphertext
}

/// Decrypt PlainText with AESCBCEncrypt
/// <example>Write ##class(Arduino.Delegated).DecryptText("sFgKzZVle187N4OqhhcXPw==")</example>
ClassMethod DecryptText(CipherText As %String) As %String
{
	Set Text=$System.Encryption.Base64Decode(CipherText)
	Set Text=$System.Encryption.AESCBCDecrypt(Text, ..GetKey(), ..GetIV())
	Set PlainText=$ZConvert(Text,"I","UTF8") 
	Return PlainText
}

/// Extends right side of a String by Character up to Length chars
/// <example>Write ##class(Arduino.Delegated).AppendToString("")</example>
ClassMethod AppendToString(String As %String, Character As %String(MAXLEN=1) = "_", Length As %Integer = {$Length(String)}) As %String
{
	Set Difference = Length - $Length(String)  
	Return:Difference<=0 String
	Set Tail = $Justify("", Difference)
	Set Tail = $Translate(Tail, " ", Character)
	Return String _ Tail
}

}