Revision 33:a4c015046956, committed 2016-03-31

Comitter:

IanBenzMaxim

Date:

Thu Mar 31 11:56:01 2016 -0500

Parent:

32:bce180b544ed

Child:

34:11fffbe98ef9

Commit message:

Created a generic array wrapper class. Updated array types used in ISha256MacCoprocessor and DS28E15_22_25 for clarity.

Changed in this revision

--- a/OneWire_Masters/DS2465/DS2465.cpp	Wed Mar 30 16:50:29 2016 -0500
+++ b/OneWire_Masters/DS2465/DS2465.cpp	Thu Mar 31 11:56:01 2016 -0500
@@ -97,7 +97,7 @@
 // Returns: true write successful
 //          false failure to complete read
 //
-OneWireMaster::CmdResult DS2465::Compute_NextMasterSecret(bool swap, unsigned int pageNum, PageRegion region)
+OneWireMaster::CmdResult DS2465::computeNextMasterSecret(bool swap, unsigned int pageNum, PageRegion region)
 {
    std::uint8_t command[2] = { CMD_CNMS, (swap ? (0xC8 | (pageNum << 4) | region) : 0xBF) };
    return WriteMemory(ADDR_CMD_REG, command, 2);
@@ -114,7 +114,7 @@
 // Returns: true write successful
 //          false failure to complete read
 //
-OneWireMaster::CmdResult DS2465::Compute_WriteMAC(bool regwrite, bool swap, unsigned int pageNum, unsigned int segmentNum) const
+OneWireMaster::CmdResult DS2465::computeWriteMac(bool regwrite, bool swap, unsigned int pageNum, unsigned int segmentNum) const
 {
    std::uint8_t command[2] = { CMD_CSWM, ((regwrite << 7) | (swap << 6) | (pageNum << 4) | segmentNum) };
    return CWriteMemory(ADDR_CMD_REG, command, 2);
@@ -130,7 +130,7 @@
 // Returns: true write successful
 //          false failure to complete read
 //
-OneWireMaster::CmdResult DS2465::Compute_AuthMAC(bool swap, unsigned int pageNum, PageRegion region) const
+OneWireMaster::CmdResult DS2465::computeAuthMac(bool swap, unsigned int pageNum, PageRegion region) const
 {
    std::uint8_t command[2] = { CMD_CSAM, (swap ? (0xC8 | (pageNum << 4) | region) : 0xBF) };
    return CWriteMemory(ADDR_CMD_REG, command, 2);
@@ -146,7 +146,7 @@
 // Returns: true write successful
 //          false failure to complete read
 //
-OneWireMaster::CmdResult DS2465::Compute_SSecret(bool swap, unsigned int pageNum, PageRegion region)
+OneWireMaster::CmdResult DS2465::computeSlaveSecret(bool swap, unsigned int pageNum, PageRegion region)
 {
    std::uint8_t command[2] = { CMD_CSS, (swap ? (0xC8 | (pageNum << 4) | region) : 0xBF) };
    return WriteMemory(ADDR_CMD_REG, command, 2);
@@ -155,10 +155,10 @@
 
 
 
-ISha256MacCoprocessor::CmdResult DS2465::setMasterSecret(const std::uint8_t (&secret)[secret_len])
+ISha256MacCoprocessor::CmdResult DS2465::setMasterSecret(const Secret & secret)
 {
   OneWireMaster::CmdResult result;
-  result = WriteMemory(ADDR_SPAD, secret, secret_len);
+  result = WriteMemory(ADDR_SPAD, secret, secret.length);
   if (result == OneWireMaster::Success)
     result = CopyScratchpad(1, 0, 1, 0);
   if (result == OneWireMaster::Success)
@@ -166,72 +166,70 @@
   return (result == OneWireMaster::Success ? ISha256MacCoprocessor::Success : ISha256MacCoprocessor::OperationFailure);
 }
 
-ISha256MacCoprocessor::CmdResult DS2465::ComputeAndRead_WriteMAC(const std::uint8_t (&WriteMAC_data)[WriteMAC_data_len], std::uint8_t (&mac)[mac_len]) const
+ISha256MacCoprocessor::CmdResult DS2465::computeWriteMac(const WriteMacData & writeMacData, Mac & mac) const
 {
   OneWireMaster::CmdResult result;
   // Write input data to scratchpad
-  result = WriteScratchpad(WriteMAC_data, WriteMAC_data_len);
+  result = WriteScratchpad(writeMacData, writeMacData.length);
   // Compute MAC
   if (result == OneWireMaster::Success)
-    result = Compute_WriteMAC(false, false, 0, 0);
+    result = computeWriteMac(false, false, 0, 0);
   if (result == OneWireMaster::Success)
   {
     wait_ms(SHA_COMPUTATION_DELAY);
     // Read MAC from register
-    result = ReadMemory(ADDR_MAC_READ, mac, mac_len, true);
+    result = ReadMemory(ADDR_MAC_READ, mac, mac.length, true);
   }
   return (result == OneWireMaster::Success ? ISha256MacCoprocessor::Success : ISha256MacCoprocessor::OperationFailure);
 }
 
-ISha256MacCoprocessor::CmdResult DS2465::ComputeAndRead_AuthMAC(const std::uint8_t (&devicePage)[devicePage_len], const std::uint8_t (&challenge)[deviceScratchpad_len],
-                                    const std::uint8_t (&AuthMAC_data)[AuthMAC_data_len], std::uint8_t (&mac)[mac_len]) const
+ISha256MacCoprocessor::CmdResult DS2465::computeAuthMac(const DevicePage & devicePage, const DeviceScratchpad & challenge, const AuthMacData & authMacData, Mac & mac) const
 {
   OneWireMaster::CmdResult result;
   int addr = ADDR_SPAD;
   // Write input data to scratchpad
-  result = CWriteMemory(addr, devicePage, devicePage_len);
+  result = CWriteMemory(addr, devicePage, devicePage.length);
   if (result == OneWireMaster::Success)
   {
-    addr += devicePage_len;
-    result = CWriteMemory(addr, challenge, deviceScratchpad_len);
+    addr += devicePage.length;
+    result = CWriteMemory(addr, challenge, challenge.length);
   }
   if (result == OneWireMaster::Success)
   {
-    addr += deviceScratchpad_len;
-    result = CWriteMemory(addr, AuthMAC_data, AuthMAC_data_len);
+    addr += challenge.length;
+    result = CWriteMemory(addr, authMacData, authMacData.length);
   }
   // Compute MAC
   if (result == OneWireMaster::Success)
-    result = Compute_AuthMAC(false, 0, REGION_FULL_PAGE);
+    result = computeAuthMac(false, 0, REGION_FULL_PAGE);
   if (result == OneWireMaster::Success)
   {
     wait_ms(SHA_COMPUTATION_DELAY * 2);
     // Read MAC from register
-    result = ReadMemory(ADDR_MAC_READ, mac, mac_len, true);
+    result = ReadMemory(ADDR_MAC_READ, mac, mac.length, true);
   }
   return (result == OneWireMaster::Success ? ISha256MacCoprocessor::Success : ISha256MacCoprocessor::OperationFailure);
 }
 
-ISha256MacCoprocessor::CmdResult DS2465::Compute_SSecret(const std::uint8_t (&devicePage)[devicePage_len], const std::uint8_t (&deviceScratchpad)[deviceScratchpad_len],
-                             const std::uint8_t (&SSecret_data)[SSecret_data_len])
+ISha256MacCoprocessor::CmdResult DS2465::computeSlaveSecret(const DevicePage & devicePage, const DeviceScratchpad & deviceScratchpad, const SlaveSecretData & slaveSecretData)
 {
   OneWireMaster::CmdResult result;
   int addr = ADDR_SPAD;
   // Write input data to scratchpad
-  result = WriteMemory(addr, devicePage, devicePage_len);
+  result = WriteMemory(addr, devicePage, devicePage.length);
   if (result == OneWireMaster::Success)
   {
-    addr += devicePage_len;
-    result = WriteMemory(addr, deviceScratchpad, deviceScratchpad_len);
+    addr += devicePage.length;
+    result = WriteMemory(addr, deviceScratchpad, deviceScratchpad.length);
   }
   if (result == OneWireMaster::Success)
   {
-    addr += deviceScratchpad_len;
-    result = WriteMemory(addr, SSecret_data, SSecret_data_len);
+    addr += deviceScratchpad.length;
+    result = WriteMemory(addr, slaveSecretData, slaveSecretData.length);
   }
   // Compute secret
   if (result == OneWireMaster::Success)
-    result = Compute_SSecret(false, 0, REGION_FULL_PAGE);
+    result = computeSlaveSecret(false, 0, REGION_FULL_PAGE);
   if (result == OneWireMaster::Success)
     wait_ms(SHA_COMPUTATION_DELAY * 2);
   return (result == OneWireMaster::Success ? ISha256MacCoprocessor::Success : ISha256MacCoprocessor::OperationFailure);

--- a/OneWire_Masters/DS2465/DS2465.hpp	Wed Mar 30 16:50:29 2016 -0500
+++ b/OneWire_Masters/DS2465/DS2465.hpp	Thu Mar 31 11:56:01 2016 -0500
@@ -82,17 +82,16 @@
   virtual OneWireMaster::CmdResult OWTriplet(SearchDirection & search_direction, std::uint8_t & sbr, std::uint8_t & tsb);
   
   //DS2465 Coprocessor Commands
-  OneWireMaster::CmdResult Compute_NextMasterSecret(bool swap, unsigned int pageNum, PageRegion region);
-  OneWireMaster::CmdResult Compute_WriteMAC(bool regwrite, bool swap, unsigned int pageNum, unsigned int segmentNum) const;
-  OneWireMaster::CmdResult Compute_SSecret(bool swap, unsigned int pageNum, PageRegion region);
-  OneWireMaster::CmdResult Compute_AuthMAC(bool swap, unsigned int pageNum, PageRegion region) const;
+  OneWireMaster::CmdResult computeNextMasterSecret(bool swap, unsigned int pageNum, PageRegion region);
+  OneWireMaster::CmdResult computeWriteMac(bool regwrite, bool swap, unsigned int pageNum, unsigned int segmentNum) const;
+  OneWireMaster::CmdResult computeSlaveSecret(bool swap, unsigned int pageNum, PageRegion region);
+  OneWireMaster::CmdResult computeAuthMac(bool swap, unsigned int pageNum, PageRegion region) const;
   
-  virtual ISha256MacCoprocessor::CmdResult setMasterSecret(const std::uint8_t (&secret)[ISha256MacCoprocessor::secret_len]);
-  virtual ISha256MacCoprocessor::CmdResult ComputeAndRead_WriteMAC(const std::uint8_t (&WriteMAC_data)[WriteMAC_data_len], std::uint8_t (&mac)[mac_len]) const;
-  virtual ISha256MacCoprocessor::CmdResult ComputeAndRead_AuthMAC(const std::uint8_t (&devicePage)[devicePage_len], const std::uint8_t (&challenge)[deviceScratchpad_len],
-                                      const std::uint8_t (&AuthMAC_data)[AuthMAC_data_len], std::uint8_t (&mac)[mac_len]) const;
-  virtual ISha256MacCoprocessor::CmdResult Compute_SSecret(const std::uint8_t (&devicePage)[devicePage_len],
-                               const std::uint8_t (&deviceScratchpad)[deviceScratchpad_len], const std::uint8_t (&SSecret_data)[SSecret_data_len]);
+  // ISha256MacCoprocessor Commands
+  virtual ISha256MacCoprocessor::CmdResult setMasterSecret(const Secret & secret);
+  virtual ISha256MacCoprocessor::CmdResult computeWriteMac(const WriteMacData & writeMacData, Mac & mac) const;
+  virtual ISha256MacCoprocessor::CmdResult computeAuthMac(const DevicePage & devicePage, const DeviceScratchpad & challenge, const AuthMacData & authMacData, Mac & mac) const;
+  virtual ISha256MacCoprocessor::CmdResult computeSlaveSecret(const DevicePage & devicePage, const DeviceScratchpad & deviceScratchpad, const SlaveSecretData & slaveSecretData);
   
 private:
   

--- a/OneWire_Masters/ISha256MacCoprocessor.hpp	Wed Mar 30 16:50:29 2016 -0500
+++ b/OneWire_Masters/ISha256MacCoprocessor.hpp	Thu Mar 31 11:56:01 2016 -0500
@@ -4,6 +4,8 @@
 #include <cstddef>
 #include <cstdint>
 
+#include "array.hpp"
+
 class ISha256MacCoprocessor
 {
 public:
@@ -13,23 +15,18 @@
     OperationFailure
   };
 
-  static const std::size_t devicePage_len = 32;
-  static const std::size_t deviceScratchpad_len = 32;
-  static const std::size_t secret_len = 32;
-  
-  static const std::size_t mac_len = 32;
+  typedef array<std::uint8_t, 32> DevicePage;
+  typedef array<std::uint8_t, 32> DeviceScratchpad;
+  typedef array<std::uint8_t, 32> Secret;
+  typedef array<std::uint8_t, 32> Mac;
+  typedef array<std::uint8_t, 20> WriteMacData;
+  typedef array<std::uint8_t, 12> AuthMacData;
+  typedef array<std::uint8_t, 12> SlaveSecretData;
   
-  static const std::size_t WriteMAC_data_len = 20;
-  static const std::size_t AuthMAC_data_len = 12;
-  static const std::size_t SSecret_data_len = 12;
-  
-  virtual CmdResult setMasterSecret(const std::uint8_t (&secret)[secret_len]) = 0;
-  
-  virtual CmdResult ComputeAndRead_WriteMAC(const std::uint8_t (&WriteMAC_data)[WriteMAC_data_len], std::uint8_t (&mac)[mac_len]) const = 0;
-  virtual CmdResult ComputeAndRead_AuthMAC(const std::uint8_t (&devicePage)[devicePage_len], const std::uint8_t (&challenge)[deviceScratchpad_len],
-                                      const std::uint8_t (&AuthMAC_data)[AuthMAC_data_len], std::uint8_t (&mac)[mac_len]) const = 0;
-  virtual CmdResult Compute_SSecret(const std::uint8_t (&devicePage)[devicePage_len],
-                               const std::uint8_t (&deviceScratchpad)[deviceScratchpad_len], const std::uint8_t (&SSecret_data)[SSecret_data_len]) = 0;
+  virtual CmdResult setMasterSecret(const Secret & secret) = 0;
+  virtual CmdResult computeWriteMac(const WriteMacData & writeMacData, Mac & mac) const = 0;
+  virtual CmdResult computeAuthMac(const DevicePage & devicePage, const DeviceScratchpad & challenge, const AuthMacData & authMacData, Mac & mac) const = 0;
+  virtual CmdResult computeSlaveSecret(const DevicePage & devicePage, const DeviceScratchpad & deviceScratchpad, const SlaveSecretData & slaveSecretData) = 0;
 };
 
 #endif
\ No newline at end of file

--- a/OneWire_Memory/Authenticators/DS28E15_22_25/DS28E15_22_25.cpp	Wed Mar 30 16:50:29 2016 -0500
+++ b/OneWire_Memory/Authenticators/DS28E15_22_25/DS28E15_22_25.cpp	Thu Mar 31 11:56:01 2016 -0500
@@ -65,7 +65,7 @@
 DS28E15_22_25::DS28E15_22_25(OneWireMaster& OW_master)
   : m_OW_master(OW_master)
 {
-  std::memset(manId, 0x00, manIdLen);
+  std::memset(manId, 0x00, manId.length);
 }
 
 DS28E15_22_25::DevicePages DS28E15_22_25::devicePages()
@@ -137,6 +137,7 @@
 {
    std::uint8_t buf[256], cs;
    int cnt = 0;
+   Mac mac;
 
    buf[cnt++] = CMD_WRITE_AUTH_PROTECT;
    buf[cnt++] = newProtection;
@@ -161,13 +162,13 @@
       return CommunicationError;
 
    ISha256MacCoprocessor::CmdResult result;
-   result = CalculateProtectionWriteMAC256(MacCoproc, newProtection, oldProtection, romId, manId, reinterpret_cast<std::uint8_t (&)[macLen]>(buf));
+   result = CalculateProtectionWriteMAC256(MacCoproc, newProtection, oldProtection, romId, manId, mac);
    if (result != ISha256MacCoprocessor::Success)
      return OperationFailure;
-   cnt = macLen;
+   cnt = 0;
 
    // send the MAC
-   m_OW_master.OWWriteBlock(&buf[0], macLen);
+   m_OW_master.OWWriteBlock(mac, mac.length);
 
    // Read CRC and CS byte
    m_OW_master.OWReadBlock(&buf[cnt], 3);
@@ -349,30 +350,24 @@
 
 
 
-ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateAuthMAC256(const ISha256MacCoprocessor & MacCoproc, unsigned int pageNum, const std::uint8_t (&challenge)[scratchpadSize], const std::uint8_t (&pageData)[pageSize], const RomId & romId, const std::uint8_t (&manId)[manIdLen], bool anon, std::uint8_t (&mac)[macLen])
+ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateAuthMAC256(const ISha256MacCoprocessor & MacCoproc, unsigned int pageNum, const Scratchpad & challenge, const Page & pageData, const RomId & romId, const ManId & manId, bool anon, Mac & mac)
 {
-   std::uint8_t pageBuf[pageSize], challengeBuf[scratchpadSize], AuthMAC_data[ISha256MacCoprocessor::AuthMAC_data_len];
-
-   // insert page data
-   std::memcpy(pageBuf, pageData, pageSize);
-
-   // insert challenge
-   std::memcpy(challengeBuf, challenge, scratchpadSize);
+   ISha256MacCoprocessor::AuthMacData authMacData;
    
    // insert ROM number or FF
    if (anon)
-     std::memset(AuthMAC_data, 0xFF, RomId::byteLen);
+     std::memset(authMacData, 0xFF, RomId::byteLen);
    else
-     std::memcpy(AuthMAC_data, romId, RomId::byteLen);
+     std::memcpy(authMacData, romId, RomId::byteLen);
 
-   AuthMAC_data[10] = pageNum;
+   authMacData[10] = pageNum;
 
-   AuthMAC_data[9] = manId[0];
-   AuthMAC_data[8] = manId[1];
+   authMacData[9] = manId[0];
+   authMacData[8] = manId[1];
    
-   AuthMAC_data[11] = 0x00;
+   authMacData[11] = 0x00;
 
-   return MacCoproc.ComputeAndRead_AuthMAC(pageBuf, challengeBuf, AuthMAC_data, mac);
+   return MacCoproc.computeAuthMac(pageData, challenge, authMacData, mac);
 }
 
 //--------------------------------------------------------------------------
@@ -390,15 +385,15 @@
 //  Returns: true - page read has correct MAC
 //           false - Failed to read page or incorrect MAC
 //
-ISha256MacCoprocessor::CmdResult DS28E15_22_25::AuthVerify(const ISha256MacCoprocessor & MacCoproc, unsigned int page_num, const std::uint8_t (&challenge)[scratchpadSize], const std::uint8_t (&pageData)[pageSize], const RomId & romId, const std::uint8_t (&manId)[manIdLen], bool anon, const std::uint8_t (&mac)[macLen])	
+ISha256MacCoprocessor::CmdResult DS28E15_22_25::AuthVerify(const ISha256MacCoprocessor & MacCoproc, unsigned int page_num, const Scratchpad & challenge, const Page & pageData, const RomId & romId, const ManId & manId, bool anon, const Mac & mac)	
 {
-  std::uint8_t calc_mac[macLen];
+  Mac calc_mac;
   ISha256MacCoprocessor::CmdResult result;
   result = CalculateAuthMAC256(MacCoproc, page_num, challenge, pageData, romId, manId, anon, calc_mac);
   if (result == ISha256MacCoprocessor::Success)
   {
-   if (memcmp(mac, calc_mac, macLen) != 0)
-     result = ISha256MacCoprocessor::OperationFailure;
+    if (mac != calc_mac)
+      result = ISha256MacCoprocessor::OperationFailure;
   }
   return result;
 }
@@ -417,7 +412,7 @@
 //  Returns: true - page read has correct MAC
 //           false - Failed to read page or incorrect MAC
 //
-OneWireSlave::CmdResult DS28E15_22_25::ComputeReadPageMAC(unsigned int page_num, bool anon, std::uint8_t (&mac)[macLen]) const	
+OneWireSlave::CmdResult DS28E15_22_25::ComputeReadPageMAC(unsigned int page_num, bool anon, Mac & mac) const	
 {
    std::uint8_t buf[256],cs;
    int cnt = 0;
@@ -450,14 +445,14 @@
       return OperationFailure;
 
    // read the MAC and CRC
-   m_OW_master.OWReadBlock(&buf[0], (macLen + 2));
+   m_OW_master.OWReadBlock(&buf[0], (Mac::length + 2));
 
    // check CRC16
-   if (OneWireMaster::calculateCRC16(buf, 0, (macLen + 2)) != 0xB001)
+   if (OneWireMaster::calculateCRC16(buf, 0, (Mac::length + 2)) != 0xB001)
       return CommunicationError;      
 
    // copy MAC to return buffer
-   memcpy(mac, buf, macLen);
+   memcpy(mac, buf, Mac::length);
 
    return Success;
 }
@@ -519,7 +514,7 @@
 // Return: true - select complete
 //         false - error during select, device not present
 //
-OneWireSlave::CmdResult DS28E15_22_25::WriteScratchpad(const uint8_t (&data)[scratchpadSize]) const
+OneWireSlave::CmdResult DS28E15_22_25::WriteScratchpad(const Scratchpad & data) const
 {
    std::uint8_t buf[256];
    int cnt = 0, offset;
@@ -540,11 +535,11 @@
    offset = cnt;
 
    // add the data
-   memcpy(&buf[cnt], data, scratchpadSize);
-   cnt += scratchpadSize;
+   memcpy(&buf[cnt], data, data.length);
+   cnt += data.length;
 
    // Send the data
-   m_OW_master.OWWriteBlock(data, scratchpadSize);
+   m_OW_master.OWWriteBlock(data, data.length);
 
    // Read CRC
    m_OW_master.OWReadBlock(&buf[cnt], 2);
@@ -620,7 +615,7 @@
 //  Returns: true - block read and verified CRC
 //           false - Failed to write block (no presence or invalid CRC16)
 //
-OneWireSlave::CmdResult DS28E15_22_25::readPage(unsigned int page, std::uint8_t (&rdbuf)[pageSize], bool continuing) const	
+OneWireSlave::CmdResult DS28E15_22_25::readPage(unsigned int page, Page & rdbuf, bool continuing) const	
 {
    std::uint8_t buf[256];
    int cnt, offset;
@@ -645,8 +640,8 @@
    }
 
    // read data and CRC16
-   m_OW_master.OWReadBlock(&buf[cnt], (pageSize + 2));
-   cnt+=34;
+   m_OW_master.OWReadBlock(&buf[cnt], (rdbuf.length + 2));
+   cnt += 34;
 
    // check the first CRC16
    if (!continuing)
@@ -660,7 +655,7 @@
       return CommunicationError;
 
    // copy the data to the read buffer
-   memcpy(rdbuf, &buf[offset], pageSize);
+   memcpy(rdbuf, &buf[offset], rdbuf.length);
 
    return Success;
 }
@@ -679,7 +674,7 @@
 //  Returns: true - block written
 //           false - Failed to write block (no presence or invalid CRC16)
 //
-OneWireSlave::CmdResult DS28E15_22_25::writeAuthSegmentMAC(unsigned int pageNum, unsigned int segmentNum, const std::uint8_t (&newData)[segmentSize], const std::uint8_t (&mac)[macLen], bool continuing)	
+OneWireSlave::CmdResult DS28E15_22_25::writeAuthSegmentMAC(unsigned int pageNum, unsigned int segmentNum, const Segment & newData, const Mac & mac, bool continuing)	
 {
    std::uint8_t buf[256], cs;
    int cnt, i, offset;
@@ -704,11 +699,11 @@
    }
 
    // add the data
-   for (i = 0; i < 4; i++)
+   for (i = 0; i < newData.length; i++)
       buf[cnt++] = newData[i];
 
    // Send data
-   m_OW_master.OWWriteBlock(newData, segmentSize);
+   m_OW_master.OWWriteBlock(newData, newData.length);
 
    // read first CRC byte
    m_OW_master.OWReadByte(buf[cnt++]);
@@ -745,10 +740,10 @@
       return CommunicationError;
 
    // transmit MAC as a block
-   m_OW_master.OWWriteBlock(mac, macLen);
+   m_OW_master.OWWriteBlock(mac, mac.length);
 
    // calculate CRC on MAC
-   CRC16 = OneWireMaster::calculateCRC16(mac, 0, macLen);
+   CRC16 = OneWireMaster::calculateCRC16(mac, 0, mac.length);
 
    // append read of CRC16 and CS byte
    m_OW_master.OWReadBlock(&buf[0], 3);
@@ -797,9 +792,9 @@
 //  Returns: true - mac calculated
 //           false - Failed to calculate
 //
-ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateSegmentWriteMAC256(const ISha256MacCoprocessor & MacCoproc, unsigned int pageNum, unsigned int segmentNum, const std::uint8_t (&newData)[segmentSize], const std::uint8_t (&oldData)[segmentSize], const RomId & romId, const std::uint8_t (&manId)[manIdLen], std::uint8_t (&mac)[macLen])	
+ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateSegmentWriteMAC256(const ISha256MacCoprocessor & MacCoproc, unsigned int pageNum, unsigned int segmentNum, const Segment & newData, const Segment & oldData, const RomId & romId, const ManId & manId, Mac & mac)	
 {
-  std::uint8_t MT[ISha256MacCoprocessor::WriteMAC_data_len];
+  ISha256MacCoprocessor::WriteMacData MT;
 
   // insert ROM number
   memcpy(&MT[0], romId, RomId::byteLen);
@@ -810,20 +805,20 @@
   MT[8] = manId[1];
 
   // insert old data
-  memcpy(&MT[12], oldData, segmentSize);
+  memcpy(&MT[12], oldData, Segment::length);
 
   // insert new data
-  memcpy(&MT[16], newData, segmentSize);
+  memcpy(&MT[16], newData, Segment::length);
   
-  return MacCoproc.ComputeAndRead_WriteMAC(MT, mac);
+  return MacCoproc.computeWriteMac(MT, mac);
 }
 
 
 
 
-ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateProtectionWriteMAC256(const ISha256MacCoprocessor & MacCoproc, std::uint8_t newProtection, std::uint8_t oldProtection, const RomId & romId, const std::uint8_t (&manId)[manIdLen], std::uint8_t (&mac)[macLen])
+ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateProtectionWriteMAC256(const ISha256MacCoprocessor & MacCoproc, std::uint8_t newProtection, std::uint8_t oldProtection, const RomId & romId, const ManId & manId, Mac & mac)
 {
-   std::uint8_t MT[ISha256MacCoprocessor::WriteMAC_data_len];
+   ISha256MacCoprocessor::WriteMacData MT;
   
    // insert ROM number
    std::memcpy(MT, romId, RomId::byteLen);
@@ -847,7 +842,7 @@
    MT[19] = (newProtection & PROT_BIT_READ) ? 0x01 : 0x00;
 
    // compute the mac
-   return MacCoproc.ComputeAndRead_WriteMAC(MT, mac);
+   return MacCoproc.computeWriteMac(MT, mac);
 }
 
 //--------------------------------------------------------------------------
@@ -868,7 +863,7 @@
 //  Returns: true - block written
 //           false - Failed to write block (no presence or invalid CRC16)
 //
-OneWireSlave::CmdResult DS28E15_22_25::writeAuthSegment(const ISha256MacCoprocessor & MacCoproc, unsigned int pageNum, unsigned int segmentNum, const std::uint8_t (&newData)[segmentSize], const std::uint8_t (&oldData)[segmentSize], bool continuing)
+OneWireSlave::CmdResult DS28E15_22_25::writeAuthSegment(const ISha256MacCoprocessor & MacCoproc, unsigned int pageNum, unsigned int segmentNum, const Segment & newData, const Segment & oldData, bool continuing)
 {
   std::uint8_t buf[256], cs;
   int cnt, offset;
@@ -893,11 +888,11 @@
    }
 
    // add the data
-   for (size_t i = 0; i < segmentSize; i++)
+   for (size_t i = 0; i < newData.length; i++)
       buf[cnt++] = newData[i];
 
    // Send data
-   m_OW_master.OWWriteBlock(newData, segmentSize);
+   m_OW_master.OWWriteBlock(newData, newData.length);
 
    // read first CRC byte
    m_OW_master.OWReadByte(buf[cnt++]);
@@ -935,16 +930,16 @@
 
     // compute the mac
    ISha256MacCoprocessor::CmdResult result;
-   result = CalculateSegmentWriteMAC256(MacCoproc, pageNum, segmentNum, newData, oldData, romId, manId, reinterpret_cast<std::uint8_t (&)[macLen]>(buf));
+   Mac mac;
+   result = CalculateSegmentWriteMAC256(MacCoproc, pageNum, segmentNum, newData, oldData, romId, manId, mac);
    if (result != ISha256MacCoprocessor::Success)
       return OperationFailure;
 
    // transmit MAC as a block
-   cnt = 0;
-   m_OW_master.OWWriteBlock(buf, macLen);
+   m_OW_master.OWWriteBlock(mac, mac.length);
 
    // calculate CRC on MAC
-   CRC16 = OneWireMaster::calculateCRC16(buf, 0, macLen);
+   CRC16 = OneWireMaster::calculateCRC16(mac, 0, mac.length);
 
    // append read of CRC16 and CS byte
    m_OW_master.OWReadBlock(&buf[0], 3);
@@ -981,7 +976,7 @@
 
 
 
-OneWireSlave::CmdResult DS28E15_22_25::readSegment(unsigned int page, unsigned int segment, std::uint8_t (&data)[segmentSize]) const
+OneWireSlave::CmdResult DS28E15_22_25::readSegment(unsigned int page, unsigned int segment, Segment & data) const
 {
   OneWireMaster::CmdResult result;
   std::uint8_t buf[2];
@@ -997,7 +992,7 @@
   
   // Receive data
   if (result == OneWireMaster::Success)
-    result = m_OW_master.OWReadBlock(data, segmentSize);
+    result = m_OW_master.OWReadBlock(data, data.length);
   
   return (result == OneWireMaster::Success ? OneWireSlave::Success : OneWireSlave::CommunicationError);
 }
@@ -1017,7 +1012,7 @@
 //  Returns: true - block written
 //           false - Failed to write block (no presence or invalid CRC16)
 //
-OneWireSlave::CmdResult DS28E15_22_25::writeSegment(unsigned int page, unsigned int block, const std::uint8_t (&data)[segmentSize], bool continuing)	
+OneWireSlave::CmdResult DS28E15_22_25::writeSegment(unsigned int page, unsigned int block, const Segment & data, bool continuing)	
 {
    std::uint8_t buf[256], cs;
    int cnt, offset;
@@ -1042,11 +1037,11 @@
    }
 
    // add the data
-   for (size_t i = 0; i < segmentSize; i++)
+   for (size_t i = 0; i < data.length; i++)
       buf[cnt++] = data[i];
 
    // Send data
-   m_OW_master.OWWriteBlock(data, segmentSize);
+   m_OW_master.OWWriteBlock(data, data.length);
 
    // Read CRC
    m_OW_master.OWReadBlock(&buf[cnt], 2);
@@ -1096,23 +1091,17 @@
 // Returns: true if compute successful
 //          false failed to do compute
 //
-ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateNextSecret(ISha256MacCoprocessor & MacCoproc, const std::uint8_t (&binding)[pageSize], const std::uint8_t (&partial)[scratchpadSize], const RomId & romId, const std::uint8_t (&manId)[manIdLen], unsigned int pageNum)
+ISha256MacCoprocessor::CmdResult DS28E15_22_25::CalculateNextSecret(ISha256MacCoprocessor & MacCoproc, const Page & binding, const Scratchpad & partial, const RomId & romId, const ManId & manId, unsigned int pageNum)
 {
-  std::uint8_t devicePage[pageSize], deviceScratchpad[scratchpadSize], SSecret_data[ISha256MacCoprocessor::SSecret_data_len];
+  ISha256MacCoprocessor::SlaveSecretData slaveSecretData;
 
-   // insert page data
-   memcpy(devicePage, binding, pageSize);
-
-   // insert challenge
-   memcpy(deviceScratchpad, partial, scratchpadSize);
+  // insert ROM number
+  std::memcpy(slaveSecretData, romId, RomId::byteLen);
 
-   // insert ROM number
-   std::memcpy(SSecret_data, romId, RomId::byteLen);
+  slaveSecretData[11] = 0x00;
+  slaveSecretData[10] = pageNum;
+  slaveSecretData[9] = manId[0];
+  slaveSecretData[8] = manId[1];
 
-   SSecret_data[11] = 0x00;
-   SSecret_data[10] = pageNum;
-   SSecret_data[9] = manId[0];
-   SSecret_data[8] = manId[1];
-
-   return MacCoproc.Compute_SSecret(devicePage, deviceScratchpad, SSecret_data);
+  return MacCoproc.computeSlaveSecret(binding, partial, slaveSecretData);
 }

--- a/OneWire_Memory/Authenticators/DS28E15_22_25/DS28E15_22_25.hpp	Wed Mar 30 16:50:29 2016 -0500
+++ b/OneWire_Memory/Authenticators/DS28E15_22_25/DS28E15_22_25.hpp	Thu Mar 31 11:56:01 2016 -0500
@@ -26,6 +26,7 @@
 #ifndef DS28E15_22_25_H
 #define DS28E15_22_25_H
 
+#include "array.hpp"
 #include "OneWire_Masters/ISha256MacCoprocessor.hpp"
 #include "OneWireSlave.hpp"
 
@@ -58,51 +59,51 @@
     UNKNOWN_BLOCKS = 0
   };
   
-  static const std::size_t pageSize = 32;
-  static const std::size_t scratchpadSize = 32;
-  static const std::size_t macLen = 32;
-
-  static const std::size_t segmentSize = 4;
-  static const std::size_t manIdLen = 2;
+  typedef array<std::uint8_t, 32> Page;
+  typedef array<std::uint8_t, 32> Scratchpad;
+  typedef array<std::uint8_t, 32> Mac;
+  typedef array<std::uint8_t, 4> Segment;
+  typedef array<std::uint8_t, 2> ManId;
   
-  std::uint8_t manId[manIdLen];
+  // Manufacturer ID
+  ManId manId;
   
   static ISha256MacCoprocessor::CmdResult CalculateSegmentWriteMAC256(const ISha256MacCoprocessor & MacCoproc,
                                           unsigned int pageNum,
                                           unsigned int segmentNum,
-                                          const std::uint8_t (&newData)[segmentSize],
-                                          const std::uint8_t (&oldData)[segmentSize],
+                                          const Segment & newData,
+                                          const Segment & oldData,
                                           const RomId & romId,
-                                          const std::uint8_t (&manId)[manIdLen],
-                                          std::uint8_t (&mac)[macLen]);
+                                          const ManId & manId,
+                                          Mac & mac);
   static ISha256MacCoprocessor::CmdResult CalculateProtectionWriteMAC256(const ISha256MacCoprocessor & MacCoproc,
                                              std::uint8_t newProtection,
                                              std::uint8_t oldProtection,
                                              const RomId & romId,
-                                             const std::uint8_t (&manId)[manIdLen],
-                                             std::uint8_t (&mac)[macLen]);
+                                             const ManId & manId,
+                                             Mac & mac);
   static ISha256MacCoprocessor::CmdResult CalculateNextSecret(ISha256MacCoprocessor & MacCoproc,
-                                  const std::uint8_t (&binding)[pageSize],
-                                  const std::uint8_t (&partial)[scratchpadSize],
+                                  const Page & binding,
+                                  const Scratchpad & partial,
                                   const RomId & romId,
-                                  const std::uint8_t (&manId)[manIdLen],
+                                  const ManId & manId,
                                   unsigned int pageNum);
   static ISha256MacCoprocessor::CmdResult CalculateAuthMAC256(const ISha256MacCoprocessor & MacCoproc,
                                   unsigned int pageNum,
-                                  const std::uint8_t (&challenge)[scratchpadSize],
-                                  const std::uint8_t (&pageData)[pageSize],
+                                  const Scratchpad & challenge,
+                                  const Page & pageData,
                                   const RomId & romId,
-                                  const std::uint8_t (&manId)[manIdLen],
+                                  const ManId & manId,
                                   bool anon,
-                                  std::uint8_t (&mac)[macLen]);
+                                  Mac & mac);
   static ISha256MacCoprocessor::CmdResult AuthVerify(const ISha256MacCoprocessor & MacCoproc,
                          unsigned int pageNum,
-                         const std::uint8_t (&challenge)[scratchpadSize],
-                         const std::uint8_t (&pageData)[pageSize],
+                         const Scratchpad & challenge,
+                         const Page & pageData,
                          const RomId & romId,
-                         const std::uint8_t (&manId)[manIdLen],
+                         const ManId & manId,
                          bool anon,
-                         const std::uint8_t (&mac)[macLen]);
+                         const Mac & mac);
   
   DS28E15_22_25(OneWireMaster & OW_master);
   
@@ -114,12 +115,12 @@
   
   //DS28Exx Specific Functions (DS28E15, DS28E22 & DS28E25)
   CmdResult LoadSecret(bool lock);
-  CmdResult WriteScratchpad(const std::uint8_t (&data)[scratchpadSize]) const;
-  CmdResult readSegment(unsigned int pageNum, unsigned int segmentNum, std::uint8_t (&data)[segmentSize]) const;
-  CmdResult writeSegment(unsigned int pageNum, unsigned int segmentNum, const std::uint8_t (&data)[segmentSize], bool continuing);
-  CmdResult readPage(unsigned int pageNum, std::uint8_t (&rdbuf)[pageSize], bool continuing) const;
+  CmdResult WriteScratchpad(const Scratchpad & data) const;
+  CmdResult readSegment(unsigned int pageNum, unsigned int segmentNum, Segment & data) const;
+  CmdResult writeSegment(unsigned int pageNum, unsigned int segmentNum, const Segment & data, bool continuing);
+  CmdResult readPage(unsigned int pageNum, Page & rdbuf, bool continuing) const;
   CmdResult ComputeSecret(unsigned int pageNum, bool lock);
-  CmdResult ComputeReadPageMAC(unsigned int pageNum, bool anon, std::uint8_t (&mac)[macLen]) const;
+  CmdResult ComputeReadPageMAC(unsigned int pageNum, bool anon, Mac & mac) const;
   CmdResult WriteBlockProtection(std::uint8_t protection, bool continuing);
   CmdResult WriteAuthBlockProtection(const ISha256MacCoprocessor & MacCoproc,
                                 std::uint8_t newProtection,
@@ -128,13 +129,13 @@
   CmdResult writeAuthSegment(const ISha256MacCoprocessor & MacCoproc,
                         unsigned int pageNum,
                         unsigned int segmentNum,
-                        const std::uint8_t (&newData)[segmentSize],
-                        const std::uint8_t (&oldData)[segmentSize],
+                        const Segment & newData,
+                        const Segment & oldData,
                         bool continuing);
   CmdResult writeAuthSegmentMAC(unsigned int pageNum,
                                 unsigned int segmentNum,
-                                const std::uint8_t (&newData)[segmentSize],
-                                const std::uint8_t (&mac)[macLen], 
+                                const Segment & newData,
+                                const Mac & mac, 
                                 bool continuing);
   
   CmdResult ReadBlockProtectionStatus(unsigned int blockNum, std::uint8_t & status);

--- a/RomId.hpp	Wed Mar 30 16:50:29 2016 -0500
+++ b/RomId.hpp	Thu Mar 31 11:56:01 2016 -0500
@@ -35,13 +35,14 @@
 #define _ROMID_HPP
 
 #include <cstdint>
-#include <cstring>
+
+#include "array.hpp"
 
 class RomId
 {
 public:
     static const std::size_t byteLen = 8;
-    typedef std::uint8_t ByteBuffer[byteLen];
+    typedef array<std::uint8_t, byteLen>::Buffer ByteBuffer;
 
     static std::uint8_t calculateCRC8(std::uint8_t crc8, std::uint8_t data);
     static std::uint8_t calculateCRC8(const std::uint8_t * data, std::size_t data_len, std::uint8_t crc = 0);
@@ -51,15 +52,15 @@
     static const std::size_t crc8Idx = 7;
     static const std::uint8_t defaultByteVal = 0x00;
 
-    ByteBuffer m_romId;
+    array<std::uint8_t, byteLen> m_romId;
 
 public:
     const RomId & operator=(const RomId & rhs) {
-        std::memcpy(this->m_romId, rhs.m_romId, byteLen);
+        this->m_romId = rhs.m_romId;
         return rhs;
     }
     bool operator==(const RomId & rhs) const {
-        return (std::memcmp(this->m_romId, rhs.m_romId, byteLen) == 0);
+        return (this->m_romId == rhs.m_romId);
     }
     bool operator!=(const RomId & rhs) const {
         return !operator==(rhs);
@@ -75,15 +76,9 @@
         std::memset(m_romId, defaultByteVal, byteLen);
     }
 
-    RomId() {
-        reset();
-    }
-    RomId(const RomId & romId) {
-        operator=(romId);
-    }
-    RomId(const ByteBuffer & romIdBytes) {
-        std::memcpy(m_romId, romIdBytes, byteLen);
-    }
+    RomId() { reset(); }
+    RomId(const RomId & romId) : m_romId(romId.m_romId) { }
+    RomId(const ByteBuffer & romIdBytes) : m_romId(romIdBytes) { }
 
     std::uint8_t familyCode() const {
         return m_romId[familyCodeIdx];

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/array.hpp	Thu Mar 31 11:56:01 2016 -0500
@@ -0,0 +1,57 @@
+#ifndef _ARRAY_HPP
+#define _ARRAY_HPP
+
+#include <cstdint>
+#include <cstring>
+
+template <typename T, std::size_t N>
+class array
+{
+public:
+  static const std::size_t length = N;
+  typedef T Buffer[N];
+  
+private:
+  Buffer m_buffer;
+  
+public:
+  const array<T, N> & operator=(const array<T, N> & rhs)
+  {
+      std::memcpy(this->m_buffer, rhs.m_buffer, N * sizeof(T));
+      return rhs;
+  }
+  
+  bool operator==(const array<T, N> & rhs) const
+  {
+    return (std::memcmp(this->m_buffer, rhs.m_buffer, N * sizeof(T)) == 0);
+  }
+  
+  bool operator!=(const array<T, N> & rhs) const
+  {
+    return !operator==(rhs);
+  }
+  
+  operator Buffer &()
+  {
+    return m_buffer; // Conversion to array reference
+  }
+  
+  operator const Buffer&() const
+  {
+    return m_buffer; // Conversion to const array reference
+  }
+  
+  array<T, N>() { }
+  
+  array<T, N>(const array<T, N> & copy)
+  {
+    operator=(copy);
+  }
+  
+  array<T, N>(const Buffer & buffer)
+  {
+    std::memcpy(m_buffer, buffer, N * sizeof(T));
+  }
+};
+
+#endif
\ No newline at end of file