How to build SAML sign-in with Android and Logto

December 22, 2024 · 2 min read

The better identity infrastructure for developers

For our new friends:

Every app needs authentication and authorization. Logto is an Auth0 alternative designed for modern apps and SaaS products.

In this article, we will go through the steps to quickly build the SAML sign-in experience (user authentication) with Android and Logto.

Prerequisites

A running Logto instance. Check out the introduction page to get started.
Basic knowledge of Android.
A usable SAML account.

Create an application in Logto

In you browser, open a new tab and enter the link of Logto Admin Console.

Get Started

Once the page is loaded, in the "Get Started" section click the View all link to open the application framework list page.

Choose your application type

Framework List

In the opening modal, scroll to the "Native app" section or filter all the available " Native app" frameworks using the quick filter checkboxes on the left.

Click the "Android (Kotlin)" / "Android (Java)" framework card to start creating your application.

Enter application name

Enter the application name, e.g., "Bookstore," and click "Create application."

🎉 Ta-da! You just created your first application in Logto. You'll see a congrats page which includes a detailed integration guide. Follow the guide to see what the experience will be in your application.

Integrate Logto SDK

tip:

The example is based on View system and View Model, but the concepts are the same when using Jetpack Compose.
The example is written in Kotlin, but the concepts are the same for Java.
Both Kotlin and Java sample projects are available on our SDK repository.
The tutorial video is available on our YouTube channel.

Installation

note:

The minimum supported Android API level of Logto Android SDK is level 24.

Before you install Logto Android SDK, ensure mavenCentral() is added to your repository configuration in the Gradle project build file:

settings.gradle.kts
dependencyResolutionManagement {
  repositories {
    mavenCentral()
  }
}

Add Logto Android SDK to your dependencies:

Kotlin
Groovy

build.gradle.kts
dependencies {
  implementation("io.logto.sdk:android:1.1.3")
}

build.gradle
dependencies {
  implementation 'io.logto.sdk:android:1.1.3'
}

Since the SDK needs internet access, you need to add the following permission to your AndroidManifest.xml file:

AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
  xmlns:tools="http://schemas.android.com/tools">

  <!-- add internet permission -->
  <uses-permission android:name="android.permission.INTERNET" />

  <!-- other configurations... -->
</manifest>

Init LogtoClient

Create a LogtoViewModel.kt and init LogtoClient in this view model:

LogtoViewModel.kt
//...with other imports
import io.logto.sdk.android.LogtoClient
import io.logto.sdk.android.type.LogtoConfig

class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    private val logtoConfig = LogtoConfig(
          endpoint = "<your-logto-endpoint>",
          appId = "<your-app-id>",
          scopes = null,
          resources = null,
          usingPersistStorage = true,
    )

    private val logtoClient = LogtoClient(logtoConfig, application)

    companion object {
        val Factory: ViewModelProvider.Factory = object : ViewModelProvider.Factory {
            @Suppress("UNCHECKED_CAST")
            override fun <T : ViewModel> create(
                modelClass: Class<T>,
                extras: CreationExtras
            ): T {
                // Get the Application object from extras
                val application = checkNotNull(extras[APPLICATION_KEY])
                return LogtoViewModel(application) as T
            }
        }
    }
}

then, create a LogtoViewModel for your MainActivity.kt:

MainActivity.kt
//...with other imports
class MainActivity : AppCompatActivity() {
    private val logtoViewModel: LogtoViewModel by viewModels { LogtoViewModel.Factory }
    //...other codes
}

Before starting, you need to add a redirect URI in the Admin Console for your application.

In Android, the redirect URI follows the pattern: $(LOGTO_REDIRECT_SCHEME)://$(YOUR_APP_PACKAGE)/callback:

The LOGTO_REDIRECT_SCHEME should be a custom scheme in the reverse domain format.
The YOUR_APP_PACKAGE is your app package name.

Assuming you treat io.logto.android as the custom LOGTO_REDIRECT_SCHEME, and io.logto.sample is your app package name, the Redirect URI should be io.logto.android://io.logto.sample/callback.

Let's switch to the Application details page of Logto Console. Add a Redirect URI io.logto.android://io.logto.sample/callback and click "Save changes".

After the redirect URI is configured, we add a signIn method to your LogtoViewModel.kt, which will call logtoClient.signIn API to invoke the Logto sign-in page:

//...with other imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...other codes
    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
        }
    }
}

Now setup on-click listener for the sign-in button in your MainActivity.kt to call the signIn method:

//...with other imports
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        //...other codes

        // Assume you have a button with id `sign_in_button` in your layout
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        signInButton.setOnClickListener {
            logtoViewModel.signIn(this)
        }
    }
}

When you click the button, the Logto SDK will navigate to the Logto sign-in page.

Implement sign-out

Similar to sign-in, we add a signOut method to LogtoViewModel.kt to call logtoClient.signOut API:

//...with other imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...other codes
    fun signOut() {
        logtoClient.signOut { logtoException ->
            logtoException?.let { println(it) }
        }
    }
}

After you signed out, the Logto SDK will clear all local credentials even though Logto exceptions occurred when calling logtoClient.signOut API.

Then, we can add a button to call the signOut method in MainActivity.kt:

//...with other imports
class MainActivity : AppCompatActivity() {
    //...other codes
    override fun onCreate(savedInstanceState: Bundle?) {
        //...other codes
        //...sign-in button codes

        // Assume you have a button with id `sign_out_button` in your layout
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        signOutButton.setOnClickListener {
            logtoViewModel.signOut()
        }
    }
}

Handle authentication status

In Logto SDK, we can use logtoClient.isAuthenticated to check the authentication status, if the user is signed in, the value will be true, otherwise, the value will be false.

Now, let's add a live data to LogtoViewModel.kt to observe the authentication status, and update the status when the user signed in or signed out:

//...with other imports
class LogtoViewModel(application: Application) : AndroidViewModel(application) {
    // ...other codes

    // Add a live data to observe the authentication status
    private val _authenticated = MutableLiveData(logtoClient.isAuthenticated)
    val authenticated: LiveData<Boolean>
        get() = _authenticated

    fun signIn(context: Activity) {
        logtoClient.signIn(context, "io.logto.android://io.logto.sample/callback") { logtoException ->
            logtoException?.let { println(it) }
            // Update the live data
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }

    fun signOut() {
        logtoClient.signOut { logtoException ->
            logtoException?.let { println(it) }
            // Update the live data
            _authenticated.postValue(logtoClient.isAuthenticated)
        }
    }
}

Then, we observe the authenticated live data in MainActivity.kt, when the user is signed in, we hide the sign-in button and show the sign-out button and vice versa:

//...with other imports
class MainActivity : AppCompatActivity() {
    //...other codes
    override fun onCreate(savedInstanceState: Bundle?) {
        //...other codes
        val signInButton = findViewById<Button>(R.id.sign_in_button)
        val signOutButton = findViewById<Button>(R.id.sign_out_button)
        // ...handle button click codes

        // Observe the authentication status
        logtoViewModel.authenticated.observe(this) { authenticated ->
            if (authenticated) {
                // The user is authenticated
                signInButton.visibility = View.GONE
                signOutButton.visibility = View.VISIBLE
            } else {
                // The user is not authenticated
                signInButton.visibility = View.VISIBLE
                signOutButton.visibility = View.GONE
            }
        }
    }
}

Test your integration:

Open your Android app to test if the integration works. When you click the "Sign In" button, the page should be redirected to a Logto sign-in page, and you should be able to create a new account by entering username and password and complete the sign-in process.

Add SAML connector

To add a social connector, go to the "Connector" tab in the Admin Console, then click on "Social connectors". From there, click "Add social connector".

In the openning modal, select "SAML" and click "Next".

On the next page, you will see a two-column layout with the README content on the left and configuration on the right.

Feel free to follow the README file in place or read the following section to complete the configuration process. If you follow the in-place guide, you can skip the next section.

Set up Standard SAML app

Let's go through configurations of SAML connector.

Before we kicking off, you can go to a social identity provider which supports SAML protocol and create your own account. Okta, OneLogin, Salesforce and some other platforms support authentication based on SAML protocol.

If your IdP mandate the encryption of SAML assertion and receiving of signed authentication requests, you should generate your private key and corresponding certificate using RSA algorithm. Keep the private key for your SP use and upload the certificate to IdP.

You also need to configure the ACS (Assertion Consumer Service) URL as ${your_logto_origin}/api/authn/saml/${connector_id} to handle IdP's SAML assertion. Where you can find your connectorId at SAML connector's details page in Logto's Admin Console.

ℹ️ Note

Per current Logto's design, we only support Redirect-binding for sending authentication request and POST-binding for receiving SAML assertion. Although this sounds not cool, but we believe that the current design can handle most of your use cases. If you have any problems, feel free to reach out!

Configure SAML connector (SP)

In this section, we will introduce each attribute in detail.

entityID `Required`

entityID (i.e. issuer) is Entity identifier. It is used to identify your entity (SAML SP entity), and match the equivalence in each SAML request/response.

signInEndpoint `Required`

The IdP's endpoint that you send SAML authentication requests to. Usually, you can find this value in IdP details page (i.e. IdP's SSO URL or Login URL).

x509Certificate `Required`

The x509 certificate generated from IdPs private key, IdP is expected to have this value available.

The content of the certificate comes with -----BEGIN CERTIFICATE----- header and -----END CERTIFICATE----- tail.

idpMetadataXml `Required`

The field is used to place contents from your IdP metadata XML file.

ℹ️ Note

The XML parser we are using does not support customized namespace. If the IdP metadata comes with namespace, you should manually remove them. For namespace of XML file, see reference.

assertionConsumerServiceUrl `Required`

The assertion consumer service (ACS) URL is the SP's endpoint to receive IdP's SAML Assertion POST requests. As we mentioned in previous part, it is usually configured at IdP settings but some IdP get this value from SAML authentication requests, we hence also add this value as a REQUIRED field. It's value should look like ${your_logto_origin}/api/authn/saml/${connector_id}.

signAuthnRequest

The boolean value that controls whether SAML authentication request should be signed, whose default value is false.

encryptAssertion

encryptAssertion is a boolean value that indicates if IdP will encrypt SAML assertion, with default value false.

ℹ️ Note

signAuthnRequest and encryptAssertion attributes should align with corresponding parameters of IdP setting, otherwise error will be thrown to show that configuration does not match. All SAML responses need to be signed.

requestSignatureAlgorithm

This should be aligned with the signature algorithms of IdP so that Logto can verify the signature of the SAML assertion. Its value should be either http://www.w3.org/2000/09/xmldsig#rsa-sha1, http://www.w3.org/2001/04/xmldsig-more#rsa-sha256 or http://www.w3.org/2001/04/xmldsig-more#rsa-sha512 and the default value is http://www.w3.org/2001/04/xmldsig-more#rsa-sha256.

messageSigningOrder

messageSigningOrder indicates the signing and encrypting order of IdP, it's value should be either sign-then-encrypt or encrypt-then-sign and the default value is sign-then-encrypt.

privateKey and privateKeyPass

privateKey is an OPTIONAL value and is required when signAuthnRequest is true.

privateKeyPass is the password you've set when creating privateKey, required when necessary.

If signAuthnRequest is true, the corresponding certificate generated from privateKey is required by IdP for checking the signature.

encPrivateKey and encPrivateKeyPass

encPrivateKey is an OPTIONAL value and is required when encryptAssertion is true.

encPrivateKeyPass is the password you've set when creating encPrivateKey, required when necessary.

If encryptAssertion is true, the corresponding certificate generated from encPrivateKey is required by IdP for encrypting SAML assertion.

ℹ️ Note

For keys and certificates generation, openssl is a wonderful tool. Here is sample command line that might be helpful:
openssl genrsa -passout pass:${privateKeyPassword} -out ${encryptPrivateKeyFilename}.pem 4096
openssl req -new -x509 -key ${encryptPrivateKeyFilename}.pem -out ${encryptionCertificateFilename}.cer -days 3650
privateKey and encPrivateKey files are enforced to be encoded in pkcs1 scheme as pem string, which means the private key files should start with -----BEGIN RSA PRIVATE KEY----- and end with -----END RSA PRIVATE KEY-----.

nameIDFormat

nameIDFormat is an OPTIONAL attribute that declares the name id format that would respond. The value can be among urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified, urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress, urn:oasis:names:tc:SAML:1.1:nameid-format:X509SubjectName, urn:oasis:names:tc:SAML:2.0:nameid-format:persistent and urn:oasis:names:tc:SAML:2.0:nameid-format:transient, and the default value is urn:oasis:names:tc:SAML:2.0:nameid-format:unspecified.

timeout

timeout is the time tolerance for time validation, since the time between your SP entity and IdP entity could be different and network connection may also bring some delay. The unit is in millisecond, and the default value is 5000 (i.e. 5s).

profileMap

Logto also provide a profileMap field that users can customize the mapping from the social vendors' profiles which are usually not standard. Each profileMap keys is Logto's standard user profile field name and corresponding value should be social profiles field name. In current stage, Logto only concern 'id', 'name', 'avatar', 'email' and 'phone' from social profile, only 'id' is REQUIRED and others are optional fields.

Config types

Name	Type	Required	Default Value
signInEndpoint	string	true
x509certificate	string	true
idpMetadataXml	string	true
entityID	string	true
assertionConsumerServiceUrl	string	true
messageSigningOrder	`encrypt-then-sign` \| `sign-then-encrypt`	false	`sign-then-encrypt`
requestSignatureAlgorithm	`http://www.w3.org/2000/09/xmldsig#rsa-sha1` \| `http://www.w3.org/2001/04/xmldsig-more#rsa-sha256` \| `http://www.w3.org/2001/04/xmldsig-more#rsa-sha512`	false	`http://www.w3.org/2001/04/xmldsig-more#rsa-sha256`
signAuthnRequest	boolean	false	false
encryptAssertion	boolean	false	false
privateKey	string	false
privateKeyPass	string	false
nameIDFormat	`urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified` \| `urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress` \| `urn:oasis:names:tc:SAML:1.1:nameid-format:X509SubjectName` \| `urn:oasis:names:tc:SAML:2.0:nameid-format:persistent` \| `urn:oasis:names:tc:SAML:2.0:nameid-format:transient`	false	`urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified`
timeout	number	false	5000
profileMap	ProfileMap	false

ProfileMap fields	Type	Required	Default value
id	string	false	id
name	string	false	name
avatar	string	false	avatar
email	string	false	email
phone	string	false	phone

Reference

Save your configuration

Double check you have filled out necessary values in the Logto connector configuration area. Click "Save and Done" (or "Save changes") and the SAML connector should be available now.

Switch to the "Sign-in experience" tab, then click the "Sign-up and sign-in" tab.

note:

If it's the first time you enter the tab, you will see a quick introduction about Sign-in Experience and its basic configuration.

Sign-in Experience tab

Select "None" for the "Sign-up identifier" to provide minimum sign-up effort for SAML sign-in, which may increase your conversion rate.

In the "Social sign-in" section, add "Add Social Connector" and choose "SAML". Then you should be able to see a button with text "Continue with SAML" in the preview section.

Save changes

Finally, click "Save changes" on the bottom right corner.

Testing and Validation

Return to your Android app. You should now be able to sign in with SAML. Enjoy!

Create an application in Logto​

Choose your application type​

Enter application name​

Integrate Logto SDK​

Installation​

Init LogtoClient​

Implement sign-in​

Implement sign-out​

Handle authentication status​

Add SAML connector​

Set up Standard SAML app​

Create social IdP's account and register SAML application (IdP)​

Configure SAML connector (SP)​

entityID Required​

signInEndpoint Required​

x509Certificate Required​

idpMetadataXml Required​

assertionConsumerServiceUrl Required​

signAuthnRequest​

encryptAssertion​

requestSignatureAlgorithm​

messageSigningOrder​

privateKey and privateKeyPass​

encPrivateKey and encPrivateKeyPass​

nameIDFormat​

timeout​

profileMap​

Config types​

Reference​

Save your configuration​

Enable SAML connector in Sign-in Experience​

Testing and Validation​

Further readings​