Diff: Utilities/Ecc256.hpp

Revision:

6:a8c83a2e6fa4

Parent:

3:f818ea5172ed

Child:

7:471901a04573

--- a/Utilities/Ecc256.hpp	Fri Jan 19 10:25:02 2018 -0600
+++ b/Utilities/Ecc256.hpp	Wed Jan 23 13:11:04 2019 -0600
@@ -34,7 +34,7 @@
 #define MaximInterface_Ecc256
 
 #include <stdint.h>
-#include "array.hpp"
+#include "array_span.hpp"
 #include "Export.h"
 #include "ManId.hpp"
 #include "RomId.hpp"
@@ -42,41 +42,187 @@
 namespace MaximInterface {
 namespace Ecc256 {
 
-typedef array<uint_least8_t, 32> Scalar;
+typedef array_span<uint_least8_t, 32> Scalar;
+
 struct Point {
-  /// Total size of all elements in bytes.
-  static const size_t size = 2 * Scalar::csize;
+  struct const_span {
+    Scalar::const_span x;
+    Scalar::const_span y;
+  };
+
+  struct span {
+    Scalar::span x;
+    Scalar::span y;
+
+    operator const_span() const {
+      const const_span sp = {x, y};
+      return sp;
+    }
+  };
+
+  struct array {
+    Scalar::array x;
+    Scalar::array y;
+
+    operator span() {
+      const span sp = {x, y};
+      return sp;
+    }
+    
+    operator const_span() const {
+      const const_span sp = {x, y};
+      return sp;
+    }
+  };
   
-  Scalar x;
-  Scalar y;
+private:
+  Point(); // deleted
 };
 
+MaximInterface_EXPORT void copy(Point::const_span src, Point::span dst);
+
 typedef Scalar PrivateKey;
 typedef Point PublicKey;
+
 struct KeyPair {
-  /// Total size of all elements in bytes.
-  static const size_t size = PrivateKey::csize + PublicKey::size;
+  struct const_span {
+    PrivateKey::const_span privateKey;
+    PublicKey::const_span publicKey;
+  };
+
+  struct span {
+    PrivateKey::span privateKey;
+    PublicKey::span publicKey;
+
+    operator const_span() const {
+      const const_span sp = {privateKey, publicKey};
+      return sp;
+    }
+  };
+
+  struct array {
+    PrivateKey::array privateKey;
+    PublicKey::array publicKey;
+
+    operator span() {
+      const span sp = {privateKey, publicKey};
+      return sp;
+    }
+    
+    operator const_span() const {
+      const const_span sp = {privateKey, publicKey};
+      return sp;
+    }
+  };
   
-  PrivateKey privateKey;
-  PublicKey publicKey;
+private:
+  KeyPair(); // deleted
 };
 
+MaximInterface_EXPORT void copy(KeyPair::const_span src, KeyPair::span dst);
+
 struct Signature {
-  /// Total size of all elements in bytes.
-  static const size_t size = 2 * Scalar::csize;
+  struct const_span {
+    Scalar::const_span r;
+    Scalar::const_span s;
+  };
+
+  struct span {
+    Scalar::span r;
+    Scalar::span s;
+
+    operator const_span() const {
+      const const_span sp = {r, s};
+      return sp;
+    }
+  };
+
+  struct array {
+    Scalar::array r;
+    Scalar::array s;
+
+    operator span() {
+      const span sp = {r, s};
+      return sp;
+    }
+    
+    operator const_span() const {
+      const const_span sp = {r, s};
+      return sp;
+    }
+  };
   
-  Scalar r;
-  Scalar s;
+private:
+  Signature(); // deleted
 };
 
+MaximInterface_EXPORT void copy(Signature::const_span src, Signature::span dst);
+
 /// Data used to create a device key certificate for ECC-256 authenticators.
-typedef array<uint_least8_t, 2 * Scalar::csize + RomId::csize + ManId::csize>
-    CertificateData;
+class CertificateData {
+public:
+  typedef array_span<uint_least8_t, 2 * Scalar::size + RomId::size + ManId::size>
+      Result;
+
+  CertificateData() : result_() {}
+
+  /// Formatted data result.
+  Result::const_span result() const { return result_; }
+
+  /// @{
+  /// Public key of the device.
+  MaximInterface_EXPORT PublicKey::span publicKey();
+  PublicKey::const_span publicKey() const {
+    return const_cast<CertificateData &>(*this).publicKey();
+  }
+  
+  CertificateData & setPublicKey(PublicKey::const_span publicKey) {
+    copy(publicKey, this->publicKey());
+    return *this;
+  }
+  /// @}
 
-/// Formats data for creating a device key certificate from the public key,
-/// ROM ID, and MAN ID.
-MaximInterface_EXPORT CertificateData createCertificateData(
-    const PublicKey & publicKey, const RomId & romId, const ManId & manId);
+  /// @{
+  /// 1-Wire ROM ID of the device.
+  RomId::span romId() {
+    return make_span(result_).subspan<romIdIdx, RomId::size>();
+  }
+  
+  RomId::const_span romId() const {
+    return const_cast<CertificateData &>(*this).romId();
+  }
+  
+  CertificateData & setRomId(RomId::const_span romId) {
+    copy(romId, this->romId());
+    return *this;
+  }
+  /// @}
+
+  /// @{
+  /// Manufacturer ID of the device.
+  ManId::span manId() {
+    return make_span(result_).subspan<manIdIdx, ManId::size>();
+  }
+  
+  ManId::const_span manId() const {
+    return const_cast<CertificateData &>(*this).manId();
+  }
+  
+  CertificateData & setManId(ManId::const_span manId) {
+    copy(manId, this->manId());
+    return *this;
+  }
+  /// @}
+
+private:
+  typedef Result::span::index_type index;
+
+  static const index publicKeyIdx = 0;
+  static const index romIdIdx = publicKeyIdx + 2 * Scalar::size;
+  static const index manIdIdx = romIdIdx + RomId::size;
+
+  Result::array result_;
+};
 
 } // namespace Ecc256
 } // namespace MaximInterface