sysio::wallet::detail::se_wallet_impl Struct Reference

Collaboration diagram for sysio::wallet::detail::se_wallet_impl:

Public Member Functions
void	populate_existing_keys ()
public_key_type	create ()
std::optional< signature_type >	try_sign_digest (const digest_type d, const public_key_type public_key)
bool	remove_key (string public_key)
	~se_wallet_impl ()

Static Public Member Functions
static public_key_data	get_public_key_data (SecKeyRef key)
static public_key_type	get_public_key (SecKeyRef key)
static string	string_for_cferror (CFErrorRef error)

Public Attributes
map< public_key_type, SecKeyRef >	_keys
fc::ec_key	key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)
bool	locked = true

Detailed Description

Definition at line 25 of file se_wallet.cpp.

Constructor & Destructor Documentation

~se_wallet_impl()

sysio::wallet::detail::se_wallet_impl::~se_wallet_impl ( )

inline

Definition at line 255 of file se_wallet.cpp.

                     {
      for(auto& k : _keys)
         CFRelease(k.second);
   }

Member Function Documentation

create()

public_key_type sysio::wallet::detail::se_wallet_impl::create ( )

inline

Definition at line 122 of file se_wallet.cpp.

                            {
      SecAccessControlRef accessControlRef = SecAccessControlCreateWithFlags(nullptr, kSecAttrAccessibleWhenUnlockedThisDeviceOnly, kSecAccessControlPrivateKeyUsage, nullptr);
 
      int keySizeValue = 256;
      CFNumberRef keySizeNumber = CFNumberCreate(NULL, kCFNumberIntType, &keySizeValue);
 
      const void* keyAttrKeys[] = {
         kSecAttrIsPermanent,
         kSecAttrAccessControl,
         kSecAttrAccessGroup
      };
      const void* keyAttrValues[] = {
         kCFBooleanTrue,
         accessControlRef,
#ifdef MAS_KEYCHAIN_GROUP
         CFSTR(XSTR(MAS_KEYCHAIN_GROUP))
#endif
      };
      CFDictionaryRef keyAttrDic = CFDictionaryCreate(NULL, keyAttrKeys, keyAttrValues, sizeof(keyAttrValues)/sizeof(keyAttrValues[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 
      const void* attrKeys[] = {
         kSecAttrKeyType,
         kSecAttrKeySizeInBits,
         kSecAttrTokenID,
         kSecPrivateKeyAttrs
      };
      const void* atrrValues[] = {
         kSecAttrKeyTypeECSECPrimeRandom,
         keySizeNumber,
         kSecAttrTokenIDSecureEnclave,
         keyAttrDic
      };
      CFDictionaryRef attributesDic = CFDictionaryCreate(NULL, attrKeys, atrrValues, sizeof(attrKeys)/sizeof(attrKeys[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 
      CFErrorRef error = NULL;
      SecKeyRef privateKey = SecKeyCreateRandomKey(attributesDic, &error);
      string error_string;
      if(error) {
         error_string = string_for_cferror(error);
         CFRelease(error);
      }
 
      CFRelease(attributesDic);
      CFRelease(keyAttrDic);
      CFRelease(keySizeNumber);
      CFRelease(accessControlRef);
 
      if(error_string.size())
         FC_THROW_EXCEPTION(chain::wallet_exception, "Failed to create key in Secure Enclave: ${m}", ("m", error_string));
 
      public_key_type pub;
      try {
         pub = get_public_key(privateKey);
      }
      catch(chain::wallet_exception&) {
         //possibly we should delete the key here?
         CFRelease(privateKey);
         throw;
      }
      _keys[pub] = privateKey;
      return pub;
   }

Here is the call graph for this function:

get_public_key()

static public_key_type sysio::wallet::detail::se_wallet_impl::get_public_key ( SecKeyRef key )

inlinestatic

Definition at line 53 of file se_wallet.cpp.

                                                        {
      char serialized_pub_key[sizeof(public_key_data) + 1];
      serialized_pub_key[0] = 0x01;
 
      public_key_data pub_key_data = get_public_key_data(key);
      memcpy(serialized_pub_key+1, pub_key_data.data, sizeof(pub_key_data));
 
      public_key_type pub_key;
      fc::datastream<const char *> ds(serialized_pub_key, sizeof(serialized_pub_key));
      fc::raw::unpack(ds, pub_key);
 
      return pub_key;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

get_public_key_data()

static public_key_data sysio::wallet::detail::se_wallet_impl::get_public_key_data ( SecKeyRef key )

inlinestatic

Definition at line 27 of file se_wallet.cpp.

                                                             {
      SecKeyRef pubkey = SecKeyCopyPublicKey(key);
 
      CFErrorRef error = nullptr;
      CFDataRef keyrep = nullptr;
      keyrep = SecKeyCopyExternalRepresentation(pubkey, &error);
 
      public_key_data pub_key_data;
      if(!error) {
         const UInt8* cfdata = CFDataGetBytePtr(keyrep);
         memcpy(pub_key_data.data+1, cfdata+1, 32);
         pub_key_data.data[0] = 0x02 + (cfdata[64]&1);
      }
 
      CFRelease(keyrep);
      CFRelease(pubkey);
 
      if(error) {
         string error_string = string_for_cferror(error);
         CFRelease(error);
         FC_THROW_EXCEPTION(chain::wallet_exception, "Failed to get public key from Secure Enclave: ${m}", ("m", error_string));
      }
 
      return pub_key_data;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

populate_existing_keys()

void sysio::wallet::detail::se_wallet_impl::populate_existing_keys ( )

inline

Definition at line 82 of file se_wallet.cpp.

                                 {
      const void* keyAttrKeys[] = {
         kSecClass,
         kSecAttrKeyClass,
         kSecMatchLimit,
         kSecReturnRef,
         kSecAttrTokenID,
         kSecAttrAccessGroup
      };
      const void* keyAttrValues[] = {
         kSecClassKey,
         kSecAttrKeyClassPrivate,
         kSecMatchLimitAll,
         kCFBooleanTrue,
         kSecAttrTokenIDSecureEnclave,
#ifdef MAS_KEYCHAIN_GROUP
         CFSTR(XSTR(MAS_KEYCHAIN_GROUP))
#endif
      };
      CFDictionaryRef keyAttrDic = CFDictionaryCreate(nullptr, keyAttrKeys, keyAttrValues, sizeof(keyAttrValues)/sizeof(keyAttrValues[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 
      CFArrayRef keyRefs = nullptr;
      if(SecItemCopyMatching(keyAttrDic, (CFTypeRef*)&keyRefs) || !keyRefs) {
         CFRelease(keyAttrDic);
         return;
      }
 
      CFIndex count = CFArrayGetCount(keyRefs);
      for(long i = 0; i < count; ++i) {
         public_key_type pub;
         try {
            SecKeyRef key = (SecKeyRef)CFRetain(CFArrayGetValueAtIndex(keyRefs, i));
            _keys[get_public_key(key)] = key;
         }
         catch(chain::wallet_exception&) {}
      }
      CFRelease(keyRefs);
      CFRelease(keyAttrDic);
   }

Here is the call graph for this function:

remove_key()

bool sysio::wallet::detail::se_wallet_impl::remove_key ( string public_key )

inline

Definition at line 230 of file se_wallet.cpp.

                                      {
      auto it = _keys.find(public_key_type{public_key});
      if(it == _keys.end())
         FC_THROW_EXCEPTION(chain::wallet_exception, "Given key to delete not found in Secure Enclave wallet");
 
      promise<bool> prom;
      future<bool> fut = prom.get_future();
      macos_user_auth(auth_callback, &prom, CFSTR("remove a key from your SYSIO wallet"));
      if(!fut.get())
         FC_THROW_EXCEPTION(chain::wallet_invalid_password_exception, "Local user authentication failed");
 
      CFDictionaryRef deleteDic = CFDictionaryCreate(nullptr, (const void**)&kSecValueRef, (const void**)&it->second, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 
      OSStatus ret = SecItemDelete(deleteDic);
      CFRelease(deleteDic);
 
      if(ret)
         FC_THROW_EXCEPTION(chain::wallet_exception, "Failed to getremove key from Secure Enclave");
 
      CFRelease(it->second);
      _keys.erase(it);
 
      return true;
   }

Here is the call graph for this function:

string_for_cferror()

static string sysio::wallet::detail::se_wallet_impl::string_for_cferror ( CFErrorRef error )

inlinestatic

Definition at line 67 of file se_wallet.cpp.

                                                      {
      CFStringRef errorString = CFCopyDescription(error);
      char buff[CFStringGetLength(errorString) + 1];
      string ret;
      if(CFStringGetCString(errorString, buff, sizeof(buff), kCFStringEncodingUTF8))
         ret = buff;
      else
         ret = "Unknown";
      CFRelease(errorString);
      return ret;
   }

Here is the caller graph for this function:

try_sign_digest()

std::optional< signature_type > sysio::wallet::detail::se_wallet_impl::try_sign_digest ( const digest_type d, const public_key_type public_key )

inline

Definition at line 185 of file se_wallet.cpp.

                                                                                                      {
      auto it = _keys.find(public_key);
      if(it == _keys.end())
         return std::optional<signature_type>{};
 
      fc::ecdsa_sig sig = ECDSA_SIG_new();
      CFErrorRef error = nullptr;
 
      CFDataRef digestData = CFDataCreateWithBytesNoCopy(nullptr, (UInt8*)d.data(), d.data_size(), kCFAllocatorNull);
      CFDataRef signature = SecKeyCreateSignature(it->second, kSecKeyAlgorithmECDSASignatureDigestX962SHA256, digestData, &error);
      if(error) {
         string error_string = string_for_cferror(error);
         CFRelease(error);
         CFRelease(digestData);
         FC_THROW_EXCEPTION(chain::wallet_exception, "Failed to sign digest in Secure Enclave: ${m}", ("m", error_string));
      }
 
      const UInt8* der_bytes = CFDataGetBytePtr(signature);
      long derSize = CFDataGetLength(signature);
      d2i_ECDSA_SIG(&sig.obj, &der_bytes, derSize);
 
      public_key_data kd;
      compact_signature compact_sig;
      try {
         kd = get_public_key_data(it->second);
         compact_sig = signature_from_ecdsa(key, kd, sig, d);
      } catch(chain::wallet_exception&) {
         CFRelease(signature);
         CFRelease(digestData);
         throw;
      }
 
      CFRelease(signature);
      CFRelease(digestData);
 
      char serialized_signature[sizeof(compact_sig) + 1];
      serialized_signature[0] = 0x01;
      memcpy(serialized_signature+1, compact_sig.data, sizeof(compact_sig));
 
      signature_type final_signature;
      fc::datastream<const char *> ds(serialized_signature, sizeof(serialized_signature));
      fc::raw::unpack(ds, final_signature);
      return final_signature;
   }

Here is the call graph for this function:

Member Data Documentation

_keys

map<public_key_type,SecKeyRef> sysio::wallet::detail::se_wallet_impl::_keys

Definition at line 260 of file se_wallet.cpp.

key

fc::ec_key sysio::wallet::detail::se_wallet_impl::key = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)

Definition at line 261 of file se_wallet.cpp.

locked

bool sysio::wallet::detail::se_wallet_impl::locked = true

Definition at line 262 of file se_wallet.cpp.

---

The documentation for this struct was generated from the following file:

• plugins/wallet_plugin/se_wallet.cpp