LiveIdentity 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ecd029a77435438d0ac1dc51726532316a09891c
+  data.tar.gz: f305c2c6fa46c66ba3bc7e26042a3d986d344a71
+SHA512:
+  metadata.gz: 71890b9398e59af0b8ab21555a0c1b6f927509a14aaf6c0f7441a0e15ce4ab56440c93789d9b71d575c1f3dfd14b08d7a770c8e26ce1538d75b19e3e9ff0ff1e
+  data.tar.gz: a47a8e61a5801d5c2ad84c7ccff47c67790f647e6a319d7274736501200e2be2fcba7ebd77e4c6ee731a7d69ded9148424f395a3e8c36066c45716c96e994905

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.1.1
+  - 2.0.0
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in LiveIdentity.gemspec
+gemspec

data/README.md

@@ -0,0 +1,44 @@
+# LiveIdentity
+
+Library utilizing IDCRL (Identity Client Runtime Library) for Microsoft Windows Live ID authentication.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'LiveIdentity'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install LiveIdentity
+
+## Unlicense
+
+![Copyright-Free](http://unlicense.org/pd-icon.png)
+
+All text, documentation, code and files in this repository are in public domain (including this text, README).
+It means you can copy, modify, distribute and include in your own work/code, even for commercial purposes, all without asking permission.
+
+[About Unlicense](http://unlicense.org/)
+
+## Contributing
+
+Feel free to improve as you see.
+
+1. Fork it ( https://github.com/davispuh/LiveIdentity/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+**Warning**: By sending pull request to this repository you dedicate any and all copyright interest in pull request (code files and all other) to the public domain. (files will be in public domain even if pull request doesn't get merged)
+
+Also before sending pull request you acknowledge that you own all copyrights or have authorization to dedicate them to public domain.
+
+If you don't want to dedicate code to public domain or if you're not allowed to (eg. you don't own required copyrights) then DON'T send pull request.
+

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new(:spec) do |t|
+end
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+end

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/lib/live_identity.rb

@@ -0,0 +1,170 @@
+require 'win_common'
+
+require_relative 'live_identity/version'
+require_relative 'live_identity/idcrl'
+
+def getStringLength(data)
+    length = 0
+    count = 0
+    offset = 0
+    previous = nil
+    while count < 2
+        data.get_bytes(offset, 100).each_byte do |byte|
+            length = length + 1
+            count = count + 1 if byte.zero? and previous.zero?
+            previous = byte
+            return length - 2 if count >= 2
+        end
+        offset += 100
+        break if offset >= 10000
+    end
+    length
+end
+
+class LiveIdentity
+    class LiveIdentityError < WinCommon::Errors::HRESULTError; end
+
+    def self.IsError?(hr)
+        WinCommon::Errors::HRESULT::IsError?(hr)
+    end
+
+    def initialize(guid, version, flags, options)
+        guidClientApplication = IDCRL::GUID.new
+        guidClientApplication.from_str(guid)
+        lPPCRLVersion = version
+        dwFlags = flags
+        dwOptions = options.count
+        pOptions = nil
+        if dwOptions > 0
+            pOptions = FFI::MemoryPointer.new(IDCRL::IDCRL_OPTION, dwOptions)
+            i = 0
+            options.each do |id, value|
+                option = IDCRL::IDCRL_OPTION.new(pOptions + i * IDCRL::IDCRL_OPTION.size)
+                option[:dwId] = id
+                option[:pValue] = FFI::MemoryPointer.new(:pointer)
+                if value.is_a?(String)
+                    data = [value.encode('UTF-16LE')].pack('a*xx')
+                    option[:pValue].write_string(data)
+                    option[:cbValue] = data.bytesize
+                else
+                    # TODO
+                end
+                i += 1
+            end
+        end
+
+        hr = IDCRL.InitializeEx(guidClientApplication, lPPCRLVersion, dwFlags, pOptions, dwOptions)
+        raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+        ObjectSpace.define_finalizer( self, self.class.finalize() )
+    end
+
+    def self.finalize()
+        Proc.new { IDCRL.Uninitialize() }
+    end
+
+    def GetIdentity(memberName, flags)
+        Identity.new(memberName, flags)
+    end
+
+    class Identity
+        attr_reader :hIdentity
+        def initialize(memberName, flags)
+            @hIdentity = nil
+            wszMemberName = [memberName.encode('UTF-16LE')].pack('a*xx')
+            dwflags = flags
+
+            pihIdentity = FFI::MemoryPointer.new(:pointer)
+            hr = IDCRL.CreateIdentityHandle(wszMemberName, dwflags, pihIdentity)
+            raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+            @hIdentity = pihIdentity.read_ulong
+            ObjectSpace.define_finalizer( self, self.class.finalize(@hIdentity) )
+        end
+
+        def self.finalize(hIdentity)
+            Proc.new do
+                hr = IDCRL.CloseIdentityHandle(hIdentity)
+                raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+            end
+        end
+
+        def SetProperty(property, value)
+            ipProperty = property
+            wszPropertyValue = [value.encode('UTF-16LE')].pack('a*xx')
+            hr = IDCRL.SetIdentityProperty(@hIdentity, ipProperty, wszPropertyValue)
+            raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+        end
+
+        def GetPropertyByName(name)
+            wszPropertyName = [name.encode('UTF-16LE')].pack('a*xx')
+            pwszPropertyValue = FFI::MemoryPointer.new(:pointer)
+            hr = IDCRL.GetIdentityPropertyByName(@hIdentity, wszPropertyName, pwszPropertyValue)
+            raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+            pwszPropertyValue = pwszPropertyValue.read_pointer.read_bytes(getStringLength(pwszPropertyValue.read_pointer))
+            pwszPropertyValue.force_encoding('UTF-16LE').encode('UTF-8')
+        end
+
+        def SetCredential(type, value)
+            wszCredType = [type.encode('UTF-16LE')].pack('a*xx')
+            wszCredValue = [value.encode('UTF-16LE')].pack('a*xx')
+            hr = IDCRL.SetCredential(@hIdentity, wszCredType, wszCredValue)
+            raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+        end
+
+        def AuthToService(target, policy, flags)
+            Service.new(self, target, policy, flags)
+        end
+
+        class ExtendedError
+            attr_reader :Category
+            attr_reader :Error
+            attr_reader :ErrorBlob
+            def initialize(identity)
+                @Category = nil
+                @Error = nil
+                @ErrorBlob = nil
+
+                hIdentity = identity.hIdentity
+                pdwCategory = FFI::MemoryPointer.new(:pointer)
+                pdwError = FFI::MemoryPointer.new(:pointer)
+                pszErrorBlob = FFI::MemoryPointer.new(:pointer)
+
+                hr = IDCRL.GetExtendedError(hIdentity, nil, pdwCategory, pdwError, pszErrorBlob)
+                raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+            end
+        end
+
+        def GetExtendedError
+            ExtendedError.new
+        end
+
+        class Service
+            attr_reader :Token
+            attr_reader :ResultFlags
+            attr_reader :SessionKey
+            def initialize(identity, target, policy, flags, sessionKey = false)
+                @Token = nil
+                @ResultFlags = nil
+                @SessionKey = nil
+
+                hIdentity = identity.hIdentity
+                szServiceTarget = [target.to_s.encode('UTF-16LE')].pack('a*xx')
+                szServicePolicy = [policy.to_s.encode('UTF-16LE')].pack('a*xx')
+                dwTokenRequestFlags = flags
+
+                szToken = FFI::MemoryPointer.new(:pointer)
+                pdwResultFlags = FFI::MemoryPointer.new(:pointer)
+                ppbSessionKey = nil
+                pcbSessionKeyLength = nil
+                if sessionKey
+                    ppbSessionKey = FFI::MemoryPointer.new(:pointer)
+                    pcbSessionKeyLength = FFI::MemoryPointer.new(:pointer)
+                end
+
+                hr = IDCRL.AuthIdentityToService(hIdentity, szServiceTarget, szServicePolicy, dwTokenRequestFlags, szToken, pdwResultFlags, ppbSessionKey, pcbSessionKeyLength)
+                raise LiveIdentityError.new(hr) if LiveIdentity::IsError?(hr)
+                szToken = szToken.read_pointer.read_bytes(getStringLength(szToken.read_pointer))
+                @Token = szToken.force_encoding('UTF-16LE').encode('UTF-8')
+            end
+        end
+    end
+end

data/lib/live_identity/idcrl.rb

@@ -0,0 +1,121 @@
+require 'ffi'
+require 'win_common/typedefs'
+require 'win_common/structs'
+
+require_relative 'idcrl/constants'
+require_relative 'idcrl/enums'
+require_relative 'idcrl/hresult'
+
+module WinCommon::Errors::HRESULT
+    include LiveIdentity::IDCRL::HRESULT
+end
+
+class LiveIdentity
+    include IDCRL::Constants
+    module IDCRL
+        extend FFI::Library
+        # http://msdn.microsoft.com/en-us/library/hh472108.aspx
+        ffi_lib 'msidcrl40'
+        ffi_convention :stdcall
+
+        include WinCommon::Structs
+        include Enums
+
+        require_relative 'idcrl/structs'
+        include Structs
+
+        typedef :pointer, :PassportIdentityHandlePointer
+        typedef :size_t,  :PassportIdentityHandle
+        typedef :pointer, :PassportEnumIdentitiesHandlePointer
+        typedef :size_t,  :PassportEnumIdentitiesHandle
+        typedef :pointer, :PIDCRL_OPTION
+
+        callback :cbIdentityChangedCallback, [:PassportEnumIdentitiesHandle, :pointer, :char], :uint
+
+        attach_function :Initialize,                           [ ], :HRESULT # TODO
+        attach_function :Uninitialize,                         [],  :HRESULT
+        attach_function :PassportFreeMemory,                   [ :pointer ], :HRESULT
+        attach_function :CreateIdentityHandle,                 [ :LPCWSTR, IDENTITY_FLAG, :PassportIdentityHandlePointer ], :HRESULT
+        attach_function :SetCredential,                        [ :PassportIdentityHandle, :LPCWSTR, :LPCWSTR ], :HRESULT
+        attach_function :GetIdentityProperty,                  [ ], :HRESULT # TODO
+        attach_function :SetIdentityProperty,                  [ :PassportIdentityHandle, :uint, :LPCWSTR ], :HRESULT
+        attach_function :CloseIdentityHandle,                  [ :PassportIdentityHandle ], :HRESULT
+        attach_function :AuthIdentityToService,                [ :PassportIdentityHandle, :LPCWSTR, :LPCWSTR, SERVICETOKENFLAGS, :PLPWSTR, :PDWORD, :PPBYTE, :PDWORD ], :HRESULT
+        attach_function :PersistCredential,                    [ ], :HRESULT # TODO
+        attach_function :RemovePersistedCredential,            [ ], :HRESULT # TODO
+        attach_function :EnumIdentitiesWithCachedCredentials,  [ :LPCWSTR, :PassportEnumIdentitiesHandlePointer ], :HRESULT
+        attach_function :NextIdentity,                         [ :PassportEnumIdentitiesHandle, :PLPWSTR ], :HRESULT
+        attach_function :CloseEnumIdentitiesHandle,            [ :PassportEnumIdentitiesHandle ], :HRESULT
+        attach_function :GetAuthState,                         [ ], :HRESULT # TODO
+        attach_function :LogonIdentity,                        [ ], :HRESULT # TODO
+        attach_function :HasPersistedCredential,               [ ], :HRESULT # TODO
+        attach_function :SetIdentityCallback,                  [ :PassportEnumIdentitiesHandle, :cbIdentityChangedCallback, :pointer ], :HRESULT
+        attach_function :InitializeEx,                         [ :REFGUID, :LONG, UPDATE_FLAG, :PIDCRL_OPTION, :DWORD ], :HRESULT
+        attach_function :GetWebAuthUrl,                        [ ], :HRESULT # TODO
+        attach_function :LogonIdentityEx,                      [ ], :HRESULT # TODO
+        attach_function :AuthIdentityToServiceEx,              [ ], :HRESULT # TODO
+        attach_function :GetAuthStateEx,                       [ ], :HRESULT # TODO
+        attach_function :GetCertificate,                       [ ], :HRESULT # TODO
+        attach_function :CancelPendingRequest,                 [ ], :HRESULT # TODO
+        attach_function :VerifyCertificate,                    [ ], :HRESULT # TODO
+        attach_function :GetIdentityPropertyByName,            [ :PassportIdentityHandle, :LPWSTR, :PLPWSTR ], :HRESULT
+        attach_function :SetExtendedProperty,                  [ ], :HRESULT # TODO
+        attach_function :GetExtendedProperty,                  [ ], :HRESULT # TODO
+        attach_function :GetServiceConfig,                     [ ], :HRESULT # TODO
+        attach_function :SetIdcrlOptions,                      [ ], :HRESULT # TODO
+        attach_function :GetWebAuthUrlEx,                      [ ], :HRESULT # TODO
+        attach_function :EncryptWithSessionKey,                [ ], :HRESULT # TODO
+        attach_function :DecryptWithSessionKey,                [ ], :HRESULT # TODO
+        attach_function :SetUserExtendedProperty,              [ ], :HRESULT # TODO
+        attach_function :GetUserExtendedProperty,              [ ], :HRESULT # TODO
+        attach_function :SetChangeNotificationCallback,        [ ], :HRESULT # TODO
+        attach_function :RemoveChangeNotificationCallback,     [ ], :HRESULT # TODO
+        attach_function :GetExtendedError,                     [ :PassportIdentityHandle, :LPVOID, :PDWORD, :PDWORD, :LPWSTR ], :HRESULT
+        attach_function :InitializeApp,                        [ ], :HRESULT # TODO
+        attach_function :EnumerateCertificates,                [ ], :HRESULT # TODO
+        attach_function :GenerateCertToken,                    [ ], :HRESULT # TODO
+        attach_function :GetDeviceId,                          [ ], :HRESULT # TODO
+        attach_function :SetDeviceConsent,                     [ ], :HRESULT # TODO
+        attach_function :GenerateDeviceToken,                  [ ], :HRESULT # TODO
+        attach_function :CreateLinkedIdentityHandle,           [ ], :HRESULT # TODO
+        attach_function :IsDeviceIDAdmin,                      [ ], :HRESULT # TODO
+        attach_function :EnumerateDeviceID,                    [ ], :HRESULT # TODO
+        attach_function :GetAssertion,                         [ ], :HRESULT # TODO
+        attach_function :VerifyAssertion,                      [ ], :HRESULT # TODO
+        attach_function :OpenAuthenticatedBrowser,             [ ], :HRESULT # TODO
+        attach_function :LogonIdentityExWithUI,                [ ], :HRESULT # TODO
+        attach_function :GetResponseForHttpChallenge,          [ ], :HRESULT # TODO
+        attach_function :GetDeviceShortLivedToken,             [ ], :HRESULT # TODO
+        attach_function :GetHIPChallenge,                      [ ], :HRESULT # TODO
+        attach_function :SetHIPSolution,                       [ ], :HRESULT # TODO
+        attach_function :SetDefaultUserForTarget,              [ ], :HRESULT # TODO
+        attach_function :GetDefaultUserForTarget,              [ ], :HRESULT # TODO
+        attach_function :UICollectCredential,                  [ ], :HRESULT # TODO
+        attach_function :AssociateDeviceToUser,                [ ], :HRESULT # TODO
+        attach_function :DisassociateDeviceFromUser,           [ ], :HRESULT # TODO
+        attach_function :EnumerateUserAssociatedDevices,       [ ], :HRESULT # TODO
+        attach_function :UpdateUserAssociatedDeviceProperties, [ ], :HRESULT # TODO
+        attach_function :UIShowWaitDialog,                     [ ], :HRESULT # TODO
+        attach_function :UIEndWaitDialog,                      [ ], :HRESULT # TODO
+        attach_function :InitializeIDCRLTraceBuffer,           [ ], :HRESULT # TODO
+        attach_function :FlushIDCRLTraceBuffer,                [ ], :HRESULT # TODO
+        attach_function :IsMappedError,                        [ ], :HRESULT # TODO
+        attach_function :GetAuthenticationStatus,              [ ], :HRESULT # TODO
+        attach_function :GetConfigDWORDValue,                  [ ], :HRESULT # TODO
+        attach_function :ProvisionDeviceId,                    [ ], :HRESULT # TODO
+        attach_function :GetDeviceIdEx,                        [ ], :HRESULT # TODO
+        attach_function :RenewDeviceId,                        [ ], :HRESULT # TODO
+        attach_function :DeProvisionDeviceId,                  [ ], :HRESULT # TODO
+        attach_function :UnPackErrorBlob,                      [ ], :HRESULT # TODO
+        attach_function :GetDefaultNoUISSOUser,                [ ], :HRESULT # TODO
+        attach_function :LogonIdentityExSSO,                   [ ], :HRESULT # TODO
+        attach_function :StartTracing,                         [ ], :HRESULT # TODO
+        attach_function :StopTracing,                          [ ], :HRESULT # TODO
+        attach_function :GetRealmInfo,                         [ ], :HRESULT # TODO
+        attach_function :CreateIdentityHandleEx,               [ ], :HRESULT # TODO
+        attach_function :AddUserToSsoGroup,                    [ ], :HRESULT # TODO
+        attach_function :GetUsersFromSsoGroup,                 [ ], :HRESULT # TODO
+        attach_function :RemoveUserFromSsoGroup,               [ ], :HRESULT # TODO
+        attach_function :SendOneTimeCode,                      [ ], :HRESULT # TODO
+    end
+end

data/lib/live_identity/idcrl/constants.rb

@@ -0,0 +1,15 @@
+class LiveIdentity
+    module IDCRL
+        module Constants
+            MaxLiveIDLength = 113
+            MaxLivePasswordLength = 31
+
+            PPCRL_CREDTYPE_MEMBERNAMEONLY      = 'ps:active'
+            PPCRL_CREDTYPE_PASSWORD            = 'ps:password'
+            PPCRL_CREDTYPE_ACTIVE              = 'ps:membernameonly'
+            PPCRL_PROPERTY_FEDERATIONBRANDNAME = 'IsDomainUser'
+            PPCRL_CREDPROPERTY_ISDOMAINUSER    = 'FederationBrandName'
+
+        end
+    end
+end

data/lib/live_identity/idcrl/enums.rb

@@ -0,0 +1,129 @@
+class LiveIdentity
+    module IDCRL
+        module Enums
+            def self.included(base)
+
+                base.const_set(:UPDATE_FLAG, base.enum(
+                :DEFAULT_UPDATE_POLICY,      0x00000000,
+                :UPDATE_DEFAULT,             0x00000000,
+                :OFFLINE_MODE_ALLOWED,       0x00000001,
+                :NO_UI,                      0x00000002,
+                :SKIP_CONNECTION_CHECK,      0x00000004,
+                :IDCRL_RESERVED_1,           0x00000008,
+                :SET_INITIALIZATION_COOKIES, 0x00000010,
+                :UPDATE_FLAG_ALL_BIT,        0x0000001F))
+
+                base.const_set(:WLIDUI_FLAG, base.enum(
+                :WLIDUI_DEFAULT,               0x0000,
+                :WLIDUI_DISABLE_REMEBERME,     0x0001,
+                :WLIDUI_DISABLE_SAVEPASSWORD,  0x0002,
+                :WLIDUI_DISABLE_DIFFERENTUSER, 0x0004,
+                :WLIDUI_DISABLE_EID,           0x0020,
+                :WLIDUI_DISABLE_SIGNUPLINK,    0x0040,
+                :WLIDUI_DISABLE_SAVEDUSERS,    0x0080,
+                :WLIDUI_FORCE_SAVEPASSWORD,    0x0100,
+                :WLIDUI_FORCE_SMARTCARD,       0x0200,
+                :WLIDUI_ALL_BIT,               0x03FF))
+
+                base.const_set(:SERVICETOKENFLAGS, base.enum(
+                :SERVICE_TOKEN_TYPE_LEGACY_PASSPORT,       0x00000001,
+                :SERVICE_TOKEN_TYPE_WEBSSO,                0x00000002,
+                :SERVICE_TOKEN_TYPE_SAML,                  0x00000002,
+                :SERVICE_TOKEN_TYPE_COMPACT_WEBSSO,        0x00000004,
+                :SERVICE_TOKEN_TYPE_X509V3,                0x00000008,
+                :SERVICE_TOKEN_CERT_IN_MEMORY_PRIVATE_KEY, 0x00000010,
+                :SERVICE_TOKEN_FROM_CACHE,                 0x00010000))
+
+                base.const_set(:IDCRL_OPTION_ID, base.enum(
+                :IDCRL_OPTION_PROXY,            0x00000001,
+                :IDCRL_OPTION_CONNECT_TIMEOUT,  0x00000002,
+                :IDCRL_OPTION_SEND_TIMEOUT,     0x00000004,
+                :IDCRL_OPTION_RECEIVE_TIMEOUT,  0x00000008,
+                :IDCRL_OPTION_PROXY_PASSWORD,   0x00000010,
+                :IDCRL_OPTION_PROXY_USERNAME,   0x00000020,
+                :IDCRL_OPTION_ENVIRONMENT,      0x00000040,
+                :IDCRL_OPTION_ALL_BIT,          0x0000007F,
+                :IDCRL_OPTION_MSC_TIMEOUT,      0x00000080))
+
+                base.const_set(:IDCRL_DEVICE_CONSENT_OPTIONS, base.enum(
+                :IDCRL_DEVICE_ID_CONSENT_MIN,    0,
+                :IDCRL_DEVICE_ID_CONSENT_GRANT,  1,
+                :IDCRL_DEVICE_ID_CONSENT_REVOKE, 2,
+                :IDCRL_DEVICE_ID_CONSENT_REMOVE, 3,
+                :IDCRL_DEVICE_ID_CONSENT_MAX,    4))
+
+                base.const_set(:IDCRL_DEVICE_ID_OPTIONS, base.enum(
+                :IDCRL_DEVICE_ID_PHYSICAL,    0x0008,
+                :IDCRL_DEVICE_ID_FROMCACHE,   0x0010,
+                :IDCRL_DEVICE_ID_ACCESSCHECK, 0x0020,
+                :IDCRL_DEVICE_ID_NO_SIGNUP,   0x0100,
+                :IDCRL_DEVICE_ID_RENEW_CERT,  0x0200))
+
+                base.const_set(:LOGON_FLAG, base.enum(
+                :LOGONIDENTITY_DEFAULT,                  0x0000,
+                :LOGONIDENTITY_ALLOW_PERSISTENT_COOKIES, 0x0008,
+                :LOGONIDENTITY_USE_EID_AUTH,             0x0010,
+                :LOGONIDENTITY_USE_LINKED_ACCOUNTS,      0x0020,
+                :LOGONIDENTITY_FEDERATED,                0x0040,
+                :LOGONIDENTITY_WLID,                     0x0080,
+                :LOGONIDENTITY_AUTO_PARTNER_REDIRECT,    0x0100,
+                :LOGONIDENTITY_IGNORE_CACHED_TOKENS,     0x0200,
+                :LOGONIDENTITY_RESERVED_1,               0x0400,
+                :LOGONIDENTITY_ALL_BIT,                  0x07FF))
+
+                base.const_set(:IDCRL_ERROR_CATEGORY, base.enum(
+                :IDCRL_REQUEST_BUILD_ERROR,          0x00000001,
+                :IDCRL_REQUEST_SEND_ERROR,           0x00000002,
+                :IDCRL_RESPONSE_RECEIVE_ERROR,       0x00000003,
+                :IDCRL_RESPONSE_READ_ERROR,          0x00000004,
+                :IDCRL_REPSONSE_PARSE_ERROR,         0x00000005,
+                :IDCRL_RESPONSE_SIG_DECRYPT_ERROR,   0x00000006,
+                :IDCRL_RESPONSE_PARSE_HEADER_ERROR,  0x00000007,
+                :IDCRL_RESPONSE_PARSE_TOKEN_ERROR,   0x00000008,
+                :IDCRL_RESPONSE_PUTCERT_ERROR,       0x00000009))
+
+                base.const_set(:PASSPORTIDENTITYPROPERTY, base.enum(
+                :IDENTITY_MEMBER_NAME, 1,
+                :IDENTITY_PUIDSTR,     2))
+
+                base.const_set(:SSO_FLAG, base.enum(
+                :SSO_DEFAULT,         0x00,
+                :SSO_NO_UI,           0x01,
+                :SSO_NO_AUTO_SIGNIN,  0x02,
+                :SSO_NO_HANDLE_ERROR, 0x04,
+                :SSO_ALL_BIT,         0x0F))
+
+                base.const_set(:IDCRL_SETOPTIONS_FLAG, base.enum(
+                :IDCRL_SETOPTIONS_SET,     0x00,
+                :IDCRL_SETOPTIONS_DEFAULT, 0x00,
+                :IDCRL_SETOPTIONS_RESET,   0x01))
+
+                base.const_set(:IDCRL_USER_DEVICE_ASSOCIATION_TYPE, base.enum(
+                :IDCRL_USER_DEVICE_SYSTEM, 0,
+                :IDCRL_USER_DEVICE_APP,    1))
+
+                base.const_set(:CERTREQUESTFLAGS, base.enum(
+                # CERT_FROM_CACHE = 0xUknown
+                ))
+
+                base.const_set(:IDENTITY_FLAG, base.enum(
+                :IDENTITY_SHARE_ALL,                 0x000000FF,
+                :IDENTITY_LOAD_FROM_PERSISTED_STORE, 0x00000100,
+                :IDENTITY_AUTHSTATE_ENCRYPTED,       0x00000200,
+                :IDENTITY_FAST_CLOSE,                0x00000400,
+                :IDENTITY_DEVICEID_LOGICAL,          0x00001000,
+                :IDENTITY_ALL_BIT,                   0x00001FFF))
+
+                base.const_set(:IDCRL_WEBAUTHOPTION, base.enum(
+                :IDCRL_WEBAUTH_NONE,       0,
+                :IDCRL_WEBAUTH_REAUTH,     1,
+                :IDCRL_WEBAUTH_PERSISTENT, 2))
+
+                base.const_set(:SERVICETOKEN_REQUEST_FLAGS, base.enum(
+                :SERVICE_TOKEN_REQUEST_TYPE_NONE,   0x00,
+                :SERVICE_TOKEN_REQUEST_TYPE_X509V3, 0x08))
+
+            end
+        end
+    end
+end

data/lib/live_identity/idcrl/hresult.rb

@@ -0,0 +1,58 @@
+class LiveIdentity
+    module IDCRL
+        module HRESULT
+            # SUCCESS
+            PPCRL_S_ALREADY_INITIALIZED                             = 0x00048044
+            PPCRL_S_STILL_INUSE                                     = 0x00048045
+            PPCRL_S_NO_MORE_IDENTITIES                              = 0x00048860
+            PPCRL_S_TOKEN_TYPE_DOES_NOT_SUPPORT_SESSION_KEY         = 0x00048861
+            PPCRL_S_NO_SUCH_CREDENTIAL                              = 0x00048862
+            PPCRL_REQUEST_S_IO_PENDING                              = 0x00048847
+            # ERRORS
+            PP_E_CRL_NOT_INITIALIZED                                = 0x80048008
+            PPCRL_NO_SESSION_KEY                                    = 0x8004800E
+            PPCRL_HRESULT_BASE                                      = 0x80048800
+            PPCRL_AUTHSTATE_E_UNAUTHENTICATED                       = 0x80048800
+            PPCRL_AUTHSTATE_E_EXPIRED                               = 0x80048801
+            PPCRL_AUTHREQUIRED_E_PASSWORD                           = 0x80048810
+            PPCRL_AUTHREQUIRED_E_UNKNOWN                            = 0x80048814
+            PPCRL_REQUEST_E_AUTH_SERVER_ERROR                       = 0x80048820
+            PPCRL_REQUEST_E_BAD_MEMBER_NAME_OR_PASSWORD             = 0x80048821
+            PPCRL_REQUEST_E_PASSWORD_LOCKED_OUT                     = 0x80048823
+            PPCRL_REQUEST_E_PASSWORD_LOCKED_OUT_BAD_PASSWORD_OR_HIP = 0x80048824
+            PPCRL_REQUEST_E_TOU_CONSENT_REQUIRED                    = 0x80048825
+            PPCRL_REQUEST_E_FORCE_RENAME_REQUIRED                   = 0x80048826
+            PPCRL_REQUEST_E_FORCE_CHANGE_PASSWORD_REQUIRED          = 0x80048827
+            PPCRL_REQUEST_E_PARTNER_NOT_FOUND                       = 0x8004882A
+            PPCRL_REQUEST_E_INVALID_POLICY                          = 0x8004882C
+            PPCRL_REQUEST_E_INVALID_MEMBER_NAME                     = 0x8004882D
+            PPCRL_REQUEST_E_MISSING_PRIMARY_CREDENTIAL              = 0x8004882E
+            PPCRL_REQUEST_E_PENDING_NETWORK_REQUEST                 = 0x8004882F
+            PPCRL_REQUEST_E_PASSWORD_EXPIRED                        = 0x80048831
+            PPCRL_E_INITIALIZED_DIFF_ENVIRONMENT                    = 0x80048046
+            PPCRL_REQUEST_E_NO_NETWORK                              = 0x80048848
+            PPCRL_REQUESTPARAMS_MISSING                             = 0x80048852
+            PPCRL_E_IDENTITY_NOT_AUTHENTICATED                      = 0x80048861
+            PPCRL_E_UNABLE_TO_RETRIEVE_SERVICE_TOKEN                = 0x80048862
+            PPCRL_E_AUTH_SERVICE_UNAVAILABLE                        = 0x80048869
+            PPCRL_E_INVALID_AUTH_SERVICE_RESPONSE                   = 0x8004886A
+            PPCRL_E_INVALIDFLAGS                                    = 0x8004886F
+            PPCRL_E_BUSY                                            = 0x80048882
+            PPCRL_E_NO_UI                                           = 0x8004889C
+            PPCRL_E_REALM_LOOKUP                                    = 0x80048895
+            PPCRL_E_NOT_UI_ERROR                                    = 0x8004889F
+            PPCRL_REQUEST_E_PARTNER_INVALID_REQUEST                 = 0x800488D6
+            PPCRL_REQUEST_E_PARTNER_REQUEST_FAILED                  = 0x800488D7
+            PPCRL_REQUEST_E_PARTNER_INVALID_SECURITY_TOKEN          = 0x800488D8
+            PPCRL_REQUEST_E_PARTNER_AUTHENTICATION_BAD_ELEMENTS     = 0x800488D9
+            PPCRL_REQUEST_E_PARTNER_BAD_REQUEST                     = 0x800488DA
+            PPCRL_REQUEST_E_PARTNER_EXPIRED_DATA                    = 0x800488DB
+            PPCRL_REQUEST_E_PARTNER_INVALID_TIME_RANGE              = 0x800488DC
+            PPCRL_REQUEST_E_PARTNER_INVALID_SCOPE                   = 0x800488DD
+            PPCRL_REQUEST_E_PARTNER_RENEW_NEEDED                    = 0x800488DE
+            PPCRL_REQUEST_E_PARTNER_UNABLE_TO_RENEW                 = 0x800488DF
+            PPCRL_REQUEST_E_CANCELLED                               = 0x800488E2
+            PPCRL_REQUEST_E_FORCE_SIGNIN                            = 0x800488E5
+        end
+    end
+end

data/lib/live_identity/idcrl/structs.rb

@@ -0,0 +1,86 @@
+class LiveIdentity
+    module IDCRL
+        module Structs
+            class IDCRL_OPTION < FFI::Struct
+                layout({
+                    :dwId    => IDCRL_OPTION_ID,
+                    :pValue  => :PBYTE,
+                    :cbValue => :size_t
+                })
+            end
+
+            class IDCRL_OPTIONS < FFI::Struct
+                layout({
+                    :dwCount    => :DWORD,
+                    :arrOptions => :pointer # *IDCRL_OPTION[]
+                })
+            end
+
+            class IDCRL_STATUS_V1 < FFI::Struct
+                layout({
+                    :hrAuthState     => :HRESULT,
+                    :hrAuthRequired  => :HRESULT,
+                    :hrRequestStatus => :HRESULT,
+                    :hrUIError       => :HRESULT,
+                    :wszWebFlowUrl   => :LPWSTR,
+                })
+            end
+
+            class PASSPORT_NAME_VALUE_PAIR < FFI::Struct
+                layout({
+                    :szName  => :LPWSTR,
+                    :szValue => :LPWSTR,
+                })
+            end
+
+            class IDCRL::UIParam < FFI::Struct
+                layout({
+                    :dwFlags               => :DWORD,
+                    :hwndParent            => :HANDLE,
+                    :wszCobrandingText     => :LPWSTR,
+                    :wszAppName            => :LPWSTR,
+                    :wszSignupText         => :LPWSTR,
+                    :wszSignupText         => :LPWSTR,
+                    :wszCobrandingLogoPath => :LPWSTR,
+                    :wszHeaderBgImage      => :LPWSTR,
+                    :dwBgColor             => :DWORD,
+                    :dwURLColor            => :DWORD,
+                    :dwTileBgColor         => :DWORD,
+                    :dwTileBdColor         => :DWORD,
+                    :dwFieldBdColor        => :DWORD,
+                    :dwCheckboxLbColor     => :DWORD,
+                    :dwBtTxtColor          => :DWORD,
+                    :dwTileLbColor         => :DWORD,
+                    :lWinLeft              => :LONG,
+                    :lWinTop               => :LONG,
+                    :wszSignupUrl          => :LPWSTR
+                })
+            end
+
+            class RSTParams < FFI::Struct
+                layout({
+                    :cbSize => :DWORD,
+                    :wzServiceTarget => :LPCWSTR,
+                    :wzServicePolicy => :LPCWSTR,
+                    :dwTokenFlags => :DWORD,
+                    :dwTokenParam => :DWORD
+                })
+            end
+
+            class PASSPORTCREDCUSTOMUI < FFI::Struct
+                layout({
+                    :cElements => :LONG,
+                    :customValues => :LPWSTR
+                })
+            end
+
+            class MultiRSTParams < FFI::Struct
+                layout({
+                    :dwRSTParamsCount => :DWORD,
+                    :pRSTParams => :pointer, # *RSTParams[]
+                    :dwMultiRSTParamsFlags => :DWORD
+                })
+            end
+        end
+    end
+end

data/lib/live_identity/version.rb

@@ -0,0 +1,3 @@
+class LiveIdentity
+    VERSION = '0.0.1'
+end

data/live_identity.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'live_identity/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'LiveIdentity'
+  spec.version       = LiveIdentity::VERSION
+  spec.authors       = ['Dāvis']
+  spec.email         = ['davispuh@gmail.com']
+  spec.summary       = 'Wrapper around IDCRL (Identity Client Runtime Library).'
+  spec.description   = 'Library utilizing IDCRL for Microsoft Windows Live ID authentication.'
+  spec.homepage      = 'https://github.com/davispuh/LiveIdentity'
+  spec.license       = 'UNLICENSE'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'WinCommon'
+  spec.add_runtime_dependency 'ffi'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+end

data/spec/live_identity_spec.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe LiveIdentity do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+require 'simplecov'
+
+SimpleCov.start
+require_relative '../lib/live_identity'

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: LiveIdentity
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dāvis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: WinCommon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library utilizing IDCRL for Microsoft Windows Live ID authentication.
+email:
+- davispuh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- README.md
+- Rakefile
+- UNLICENSE
+- lib/live_identity.rb
+- lib/live_identity/idcrl.rb
+- lib/live_identity/idcrl/constants.rb
+- lib/live_identity/idcrl/enums.rb
+- lib/live_identity/idcrl/hresult.rb
+- lib/live_identity/idcrl/structs.rb
+- lib/live_identity/version.rb
+- live_identity.gemspec
+- spec/live_identity_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/davispuh/LiveIdentity
+licenses:
+- UNLICENSE
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Wrapper around IDCRL (Identity Client Runtime Library).
+test_files:
+- spec/live_identity_spec.rb
+- spec/spec_helper.rb
+has_rdoc: