From 9c1c8a21885a6d257e742e3d10c1b0b0b2689377 Mon Sep 17 00:00:00 2001 From: Yosi Haran Date: Fri, 20 Nov 2026 01:14:53 +0200 Subject: [PATCH 1/2] feat(auth): add OTP IM delivery and missing OTP request options --- README.md | 38 +- .../com/descope/enums/DeliveryMethod.java | 4 +- .../descope/model/auth/AssociatedTenant.java | 13 + .../model/auth/AuthenticationInfo.java | 29 ++ .../com/descope/model/auth/IDPResponse.java | 13 + .../com/descope/model/auth/UpdateOptions.java | 12 + .../model/jwt/response/JWTResponse.java | 28 ++ .../descope/model/magiclink/LoginOptions.java | 12 + .../model/magiclink/SignUpOptions.java | 10 + .../descope/model/otp/OTPSignInOptions.java | 18 + .../descope/model/otp/OTPSignUpOptions.java | 16 + .../com/descope/model/otp/SignInRequest.java | 9 + .../com/descope/model/otp/SignUpRequest.java | 12 + .../model/otp/UpdateEmailRequestBody.java | 14 + .../model/otp/UpdatePhoneRequestBody.java | 14 + .../java/com/descope/model/user/User.java | 12 + .../model/user/response/UserFamily.java | 17 + .../model/user/response/UserResponse.java | 70 ++++ .../java/com/descope/sdk/auth/OTPService.java | 48 +++ .../sdk/auth/impl/AuthenticationsBase.java | 22 +- .../sdk/auth/impl/MagicLinkServiceImpl.java | 10 + .../descope/sdk/auth/impl/OTPServiceImpl.java | 54 ++- .../sdk/mgmt/impl/UserServiceImpl.java | 6 + .../auth/impl/MagicLinkServiceImplTest.java | 12 + .../sdk/auth/impl/OTPServiceImplTest.java | 354 ++++++++++++++++++ .../sdk/mgmt/impl/UserServiceImplTest.java | 10 + 26 files changed, 850 insertions(+), 7 deletions(-) create mode 100644 src/main/java/com/descope/model/otp/OTPSignInOptions.java create mode 100644 src/main/java/com/descope/model/otp/OTPSignUpOptions.java create mode 100644 src/main/java/com/descope/model/user/response/UserFamily.java diff --git a/README.md b/README.md index b12d8837..3710695e 100644 --- a/README.md +++ b/README.md @@ -110,7 +110,7 @@ For rate limiting information, please confer to the [API Rate Limits](#api-rate- ### OTP Authentication -Send a user a one-time password (OTP) using your preferred delivery method (_email / SMS / Voice call / WhatsApp_). An email address or phone number must be provided accordingly. +Send a user a one-time password (OTP) using your preferred delivery method (_email / SMS / Voice call / WhatsApp / instant message_). An email address or phone number must be provided accordingly. The user can either `sign up`, `sign in` or `sign up or in` @@ -130,6 +130,26 @@ try { } ``` +Sign-up can also take login options and a messaging provider or template. Sign-in and sign-up-or-in take the same +provider and template, plus an SSO app and recovery flag: + +```java +String maskedPhone = otps.signUp(DeliveryMethod.IM, "+12125551234", + User.builder().phone("+12125551234").recoveryEmail("desmond@descope.com").build(), + SignUpOptions.builder().tenantId("tenant-ID").locale("en").build(), + OTPSignUpOptions.builder().providerId("provider-ID").templateId("template-ID").build()); + +OTPSignInOptions signInOptions = OTPSignInOptions.builder() + .providerId("provider-ID") + .templateId("template-ID") + .ssoAppId("sso-app-ID") + .useRecovery(false) + .build(); +String maskedAddress = otps.signIn(DeliveryMethod.EMAIL, loginId, + LoginOptions.builder().tenantId("tenant-ID").build(), null, signInOptions); +maskedAddress = otps.signUpOrIn(DeliveryMethod.EMAIL, loginId, null, signInOptions); +``` + The user will receive a code using the selected delivery method. Verify that code using: ```java @@ -143,6 +163,22 @@ try { The session and refresh JWTs should be returned to the caller, and passed with every request in the session. Read more on [session validation](#session-validation) +`AuthenticationInfo` also carries the cookie settings (`getCookieName()`, `getCookieDomain()`, `getCookiePath()`, `getCookieMaxAge()`, `getCookieExpiration()`) and the other values of the verify response, such as `getTenantSSOID()` and `getTrustedDeviceJwt()`. + +To update a logged-in user's email or phone with an OTP, pass the user's refresh token. The update options can set the messaging provider, template, locale, conflict handling and MFA: + +```java +UpdateOptions updateOptions = UpdateOptions.builder() + .providerId("provider-ID") + .templateId("template-ID") + .locale("en") + .failOnConflict(true) + .mfa(true) // keep the refresh token's auth methods and add the verified address to them + .build(); +String maskedEmail = otps.updateUserEmail(loginId, "new@descope.com", refreshToken, updateOptions); +String maskedPhone = otps.updateUserPhone(DeliveryMethod.SMS, loginId, "+12125551234", refreshToken, updateOptions); +``` + ### Magic Link Send a user a Magic Link using your preferred delivery method (_email / SMS / WhatsApp_). diff --git a/src/main/java/com/descope/enums/DeliveryMethod.java b/src/main/java/com/descope/enums/DeliveryMethod.java index 6859f24a..c763e49b 100644 --- a/src/main/java/com/descope/enums/DeliveryMethod.java +++ b/src/main/java/com/descope/enums/DeliveryMethod.java @@ -6,7 +6,9 @@ public enum DeliveryMethod { EMAIL("email"), SMS("sms"), VOICE("voice"), - WHATSAPP("whatsapp"); + WHATSAPP("whatsapp"), + /** Instant message, supported by OTP only. */ + IM("im"); @Getter private final String value; diff --git a/src/main/java/com/descope/model/auth/AssociatedTenant.java b/src/main/java/com/descope/model/auth/AssociatedTenant.java index 1798deae..a7adeb2b 100644 --- a/src/main/java/com/descope/model/auth/AssociatedTenant.java +++ b/src/main/java/com/descope/model/auth/AssociatedTenant.java @@ -1,5 +1,6 @@ package com.descope.model.auth; +import com.fasterxml.jackson.annotation.JsonProperty; import java.util.List; import lombok.AllArgsConstructor; import lombok.Builder; @@ -14,4 +15,16 @@ public class AssociatedTenant { private String tenantId; private String tenantName; private List roleNames; + // Response only: never sent back when a loaded tenant is reused in a request + @JsonProperty(access = JsonProperty.Access.WRITE_ONLY) + private List permissions; + /** Role IDs, not in the same order as roleNames. */ + @JsonProperty(access = JsonProperty.Access.WRITE_ONLY) + private List roleIds; + + public AssociatedTenant(String tenantId, String tenantName, List roleNames) { + this.tenantId = tenantId; + this.tenantName = tenantName; + this.roleNames = roleNames; + } } diff --git a/src/main/java/com/descope/model/auth/AuthenticationInfo.java b/src/main/java/com/descope/model/auth/AuthenticationInfo.java index b4a5666d..fd5bd4dd 100644 --- a/src/main/java/com/descope/model/auth/AuthenticationInfo.java +++ b/src/main/java/com/descope/model/auth/AuthenticationInfo.java @@ -2,6 +2,7 @@ import com.descope.model.jwt.Token; import com.descope.model.user.response.UserResponse; +import java.util.Map; import lombok.AllArgsConstructor; import lombok.Data; @@ -13,8 +14,36 @@ public class AuthenticationInfo { private UserResponse user; private Boolean firstSeen; private IDPResponse idpResponse; + private String cookieDomain; + private String cookiePath; + private Integer cookieMaxAge; + /** Cookie expiration in unix seconds. */ + private Integer cookieExpiration; + private Integer sessionExpiration; + private String externalToken; + private Map claims; + private String tenantSSOID; + private String trustedDeviceJwt; + private Integer nextRefreshSeconds; + private String cookieName; + private String sessionCookieName; + private String sessionCookieDomain; + private Boolean unsavedSSO; + private String knownDeviceJwt; + /** Set when an authentication-only SSO verified the person without creating or signing in a user. */ + private Boolean ssoAuthenticationOnly; + private Boolean userCreationDeferred; public AuthenticationInfo(Token token, Token refreshToken, UserResponse user, Boolean firstSeen) { this(token, refreshToken, user, firstSeen, null); } + + public AuthenticationInfo(Token token, Token refreshToken, UserResponse user, Boolean firstSeen, + IDPResponse idpResponse) { + this.token = token; + this.refreshToken = refreshToken; + this.user = user; + this.firstSeen = firstSeen; + this.idpResponse = idpResponse; + } } diff --git a/src/main/java/com/descope/model/auth/IDPResponse.java b/src/main/java/com/descope/model/auth/IDPResponse.java index 60bf41e8..b7f70a87 100644 --- a/src/main/java/com/descope/model/auth/IDPResponse.java +++ b/src/main/java/com/descope/model/auth/IDPResponse.java @@ -13,4 +13,17 @@ public class IDPResponse { private List idpGroups; private Map idpSAMLAttributes; private Map idpOIDCClaims; + private String samlResponse; + private String samlGeneratedUser; + private String samlGeneratedRoles; + private String oidcResponse; + private String oidcGeneratedUser; + private String oidcGeneratedRoles; + + public IDPResponse(List idpGroups, Map idpSAMLAttributes, + Map idpOIDCClaims) { + this.idpGroups = idpGroups; + this.idpSAMLAttributes = idpSAMLAttributes; + this.idpOIDCClaims = idpOIDCClaims; + } } diff --git a/src/main/java/com/descope/model/auth/UpdateOptions.java b/src/main/java/com/descope/model/auth/UpdateOptions.java index 31b5846b..612bcb86 100644 --- a/src/main/java/com/descope/model/auth/UpdateOptions.java +++ b/src/main/java/com/descope/model/auth/UpdateOptions.java @@ -12,4 +12,16 @@ public class UpdateOptions { private boolean addToLoginIds; private boolean onMergeUseExisting; + // Fields below are sent by OTP updates only + private String providerId; + private String templateId; + private String locale; + private Boolean failOnConflict; + /** Keep the refresh token's auth methods and add the verified address to them; needs a valid refresh token. */ + private Boolean mfa; + + public UpdateOptions(boolean addToLoginIds, boolean onMergeUseExisting) { + this.addToLoginIds = addToLoginIds; + this.onMergeUseExisting = onMergeUseExisting; + } } \ No newline at end of file diff --git a/src/main/java/com/descope/model/jwt/response/JWTResponse.java b/src/main/java/com/descope/model/jwt/response/JWTResponse.java index 763fa8c0..0483eebc 100644 --- a/src/main/java/com/descope/model/jwt/response/JWTResponse.java +++ b/src/main/java/com/descope/model/jwt/response/JWTResponse.java @@ -2,6 +2,7 @@ import com.descope.model.auth.IDPResponse; import com.descope.model.user.response.UserResponse; +import java.util.Map; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; @@ -19,10 +20,37 @@ public class JWTResponse { private UserResponse user; private Boolean firstSeen; private IDPResponse idpResponse; + private Integer sessionExpiration; + private String externalToken; + private Map claims; + private String tenantSSOID; + private String trustedDeviceJwt; + private Integer nextRefreshSeconds; + private String cookieName; + private String sessionCookieName; + private String sessionCookieDomain; + private Boolean unsavedSSO; + private String knownDeviceJwt; + /** Set when an authentication-only SSO verified the person without creating or signing in a user. */ + private Boolean ssoAuthenticationOnly; + private Boolean userCreationDeferred; public JWTResponse(String sessionJwt, String refreshJwt, String cookieDomain, String cookiePath, Integer cookieMaxAge, Integer cookieExpiration, UserResponse user, Boolean firstSeen) { this(sessionJwt, refreshJwt, cookieDomain, cookiePath, cookieMaxAge, cookieExpiration, user, firstSeen, null); } + + public JWTResponse(String sessionJwt, String refreshJwt, String cookieDomain, String cookiePath, + Integer cookieMaxAge, Integer cookieExpiration, UserResponse user, Boolean firstSeen, IDPResponse idpResponse) { + this.sessionJwt = sessionJwt; + this.refreshJwt = refreshJwt; + this.cookieDomain = cookieDomain; + this.cookiePath = cookiePath; + this.cookieMaxAge = cookieMaxAge; + this.cookieExpiration = cookieExpiration; + this.user = user; + this.firstSeen = firstSeen; + this.idpResponse = idpResponse; + } } diff --git a/src/main/java/com/descope/model/magiclink/LoginOptions.java b/src/main/java/com/descope/model/magiclink/LoginOptions.java index de3b9ac2..f2a2710b 100644 --- a/src/main/java/com/descope/model/magiclink/LoginOptions.java +++ b/src/main/java/com/descope/model/magiclink/LoginOptions.java @@ -20,6 +20,10 @@ public class LoginOptions { private String jwt; private String locale; private String templateId; + private String ssoAppId; + /** Base64-encoded PKCE challenge, used by enchanted links only. */ + private String pkceChallenge; + private String tenantId; public LoginOptions(boolean stepup, boolean mfa, Map customClaims, Map templateOptions) { @@ -41,6 +45,14 @@ public LoginOptions(boolean stepup, boolean mfa, Map customClaim this.jwt = jwt; } + public LoginOptions(boolean stepup, boolean mfa, Map customClaims, + Map templateOptions, boolean revokeOtherSessions, + String[] revokeOtherSessionsTypes, String jwt, String locale, String templateId) { + this(stepup, mfa, customClaims, templateOptions, revokeOtherSessions, revokeOtherSessionsTypes, jwt); + this.locale = locale; + this.templateId = templateId; + } + public boolean isJWTRequired() { return this.isStepup() || this.isMfa(); } diff --git a/src/main/java/com/descope/model/magiclink/SignUpOptions.java b/src/main/java/com/descope/model/magiclink/SignUpOptions.java index 1010d3b3..ae24e174 100644 --- a/src/main/java/com/descope/model/magiclink/SignUpOptions.java +++ b/src/main/java/com/descope/model/magiclink/SignUpOptions.java @@ -13,4 +13,14 @@ public class SignUpOptions { private Map customClaims; private Map templateOptions; + private String locale; + /** Base64-encoded PKCE challenge, used by enchanted links only. */ + private String pkceChallenge; + private String templateId; + private String tenantId; + + public SignUpOptions(Map customClaims, Map templateOptions) { + this.customClaims = customClaims; + this.templateOptions = templateOptions; + } } diff --git a/src/main/java/com/descope/model/otp/OTPSignInOptions.java b/src/main/java/com/descope/model/otp/OTPSignInOptions.java new file mode 100644 index 00000000..f0240164 --- /dev/null +++ b/src/main/java/com/descope/model/otp/OTPSignInOptions.java @@ -0,0 +1,18 @@ +package com.descope.model.otp; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** Request options for OTP sign-in and sign-up-or-in, sent next to the login options. */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class OTPSignInOptions { + private String providerId; + private String templateId; + private String ssoAppId; + private Boolean useRecovery; +} diff --git a/src/main/java/com/descope/model/otp/OTPSignUpOptions.java b/src/main/java/com/descope/model/otp/OTPSignUpOptions.java new file mode 100644 index 00000000..7a7c4dc5 --- /dev/null +++ b/src/main/java/com/descope/model/otp/OTPSignUpOptions.java @@ -0,0 +1,16 @@ +package com.descope.model.otp; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** Request options for OTP sign-up, sent next to the sign-up login options. */ +@Data +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class OTPSignUpOptions { + private String providerId; + private String templateId; +} diff --git a/src/main/java/com/descope/model/otp/SignInRequest.java b/src/main/java/com/descope/model/otp/SignInRequest.java index 4e8ea75b..f825db88 100644 --- a/src/main/java/com/descope/model/otp/SignInRequest.java +++ b/src/main/java/com/descope/model/otp/SignInRequest.java @@ -14,4 +14,13 @@ public class SignInRequest { private String loginId; private LoginOptions loginOptions; + private String providerId; + private String templateId; + private String ssoAppId; + private Boolean useRecovery; + + public SignInRequest(String loginId, LoginOptions loginOptions) { + this.loginId = loginId; + this.loginOptions = loginOptions; + } } diff --git a/src/main/java/com/descope/model/otp/SignUpRequest.java b/src/main/java/com/descope/model/otp/SignUpRequest.java index fe02a4f6..d761756a 100644 --- a/src/main/java/com/descope/model/otp/SignUpRequest.java +++ b/src/main/java/com/descope/model/otp/SignUpRequest.java @@ -18,4 +18,16 @@ public class SignUpRequest { private String loginId; private User user; private SignUpOptions loginOptions; + private String providerId; + private String templateId; + + public SignUpRequest(String whatsApp, String phone, String email, String loginId, User user, + SignUpOptions loginOptions) { + this.whatsApp = whatsApp; + this.phone = phone; + this.email = email; + this.loginId = loginId; + this.user = user; + this.loginOptions = loginOptions; + } } diff --git a/src/main/java/com/descope/model/otp/UpdateEmailRequestBody.java b/src/main/java/com/descope/model/otp/UpdateEmailRequestBody.java index f9c912b2..1d7cdc5c 100644 --- a/src/main/java/com/descope/model/otp/UpdateEmailRequestBody.java +++ b/src/main/java/com/descope/model/otp/UpdateEmailRequestBody.java @@ -18,4 +18,18 @@ public class UpdateEmailRequestBody { private boolean addToLoginIds; private boolean onMergeUseExisting; private Map templateOptions; + private String providerId; + private String templateId; + private String locale; + private Boolean failOnConflict; + private Boolean mfa; + + public UpdateEmailRequestBody(String email, String loginId, boolean addToLoginIds, boolean onMergeUseExisting, + Map templateOptions) { + this.email = email; + this.loginId = loginId; + this.addToLoginIds = addToLoginIds; + this.onMergeUseExisting = onMergeUseExisting; + this.templateOptions = templateOptions; + } } diff --git a/src/main/java/com/descope/model/otp/UpdatePhoneRequestBody.java b/src/main/java/com/descope/model/otp/UpdatePhoneRequestBody.java index 92f27a9d..31364a28 100644 --- a/src/main/java/com/descope/model/otp/UpdatePhoneRequestBody.java +++ b/src/main/java/com/descope/model/otp/UpdatePhoneRequestBody.java @@ -18,4 +18,18 @@ public class UpdatePhoneRequestBody { private boolean addToLoginIds; private boolean onMergeUseExisting; private Map templateOptions; + private String providerId; + private String templateId; + private String locale; + private Boolean failOnConflict; + private Boolean mfa; + + public UpdatePhoneRequestBody(String phone, String loginId, boolean addToLoginIds, boolean onMergeUseExisting, + Map templateOptions) { + this.phone = phone; + this.loginId = loginId; + this.addToLoginIds = addToLoginIds; + this.onMergeUseExisting = onMergeUseExisting; + this.templateOptions = templateOptions; + } } diff --git a/src/main/java/com/descope/model/user/User.java b/src/main/java/com/descope/model/user/User.java index 05cae442..4679df31 100644 --- a/src/main/java/com/descope/model/user/User.java +++ b/src/main/java/com/descope/model/user/User.java @@ -16,8 +16,20 @@ public class User { private String givenName; private String middleName; private String familyName; + private String loginId; + private String recoveryEmail; + private String recoveryPhone; public User(String name, String email, String phone) { this(name, email, phone, null, null, null); } + + public User(String name, String email, String phone, String givenName, String middleName, String familyName) { + this.name = name; + this.email = email; + this.phone = phone; + this.givenName = givenName; + this.middleName = middleName; + this.familyName = familyName; + } } diff --git a/src/main/java/com/descope/model/user/response/UserFamily.java b/src/main/java/com/descope/model/user/response/UserFamily.java new file mode 100644 index 00000000..636e9b8f --- /dev/null +++ b/src/main/java/com/descope/model/user/response/UserFamily.java @@ -0,0 +1,17 @@ +package com.descope.model.user.response; + +import java.util.List; +import java.util.Map; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class UserFamily { + private String familyId; + private List roleNames; + private List permissions; + private Map familyScopedAttributes; +} diff --git a/src/main/java/com/descope/model/user/response/UserResponse.java b/src/main/java/com/descope/model/user/response/UserResponse.java index 1f933492..6df815b1 100644 --- a/src/main/java/com/descope/model/user/response/UserResponse.java +++ b/src/main/java/com/descope/model/user/response/UserResponse.java @@ -1,11 +1,14 @@ package com.descope.model.user.response; import com.descope.model.auth.AssociatedTenant; +import com.fasterxml.jackson.annotation.JsonAlias; +import com.fasterxml.jackson.annotation.JsonProperty; import java.util.List; import java.util.Map; import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; +import lombok.Setter; @Data @NoArgsConstructor @@ -29,8 +32,12 @@ public class UserResponse { Boolean test; Long createdTime; Map customAttributes; + // Aliases accept the spec's names; the getters' lowercase names still work + @Setter(onMethod_ = {@JsonAlias({"TOTP"})}) Boolean TOTP; + @Setter(onMethod_ = {@JsonAlias({"SAML"})}) Boolean SAML; + @Setter(onMethod_ = {@JsonAlias({"OAuth"})}) Map oAuth; List ssoAppIds; /** Auth method that triggered brute-force protection, empty when none. */ @@ -40,4 +47,67 @@ public class UserResponse { * this is greater than now. */ Long tempLockExpiration; + List externalIds; + Boolean webauthn; + Boolean password; + Boolean editable; + @JsonProperty("SCIM") + @JsonAlias({"scim"}) + Boolean scim; + Boolean push; + List permissions; + @JsonProperty("OIDC") + @JsonAlias({"oidc"}) + Boolean oidc; + Long consentExpiration; + String recoveryEmail; + Boolean verifiedRecoveryEmail; + String recoveryPhone; + Boolean verifiedRecoveryPhone; + Long modifiedTime; + /** Role IDs, not in the same order as roleNames. */ + List roleIds; + /** Whether the user has set up recovery codes. */ + Boolean recoveryCodes; + Boolean dependent; + List userFamilies; + /** Tenant whose SCIM connection provisioned the user, empty when none or ambiguous. */ + String scimTenantId; + /** Tenant whose SAML SSO created the user or merged its login, empty when none or ambiguous. */ + String samlTenantId; + /** Tenant whose OIDC SSO created the user or merged its login, empty when none or ambiguous. */ + String oidcTenantId; + String consentTenantId; + /** Last authentication time in unix seconds, 0 when the user never logged in. */ + Long lastLoginTime; + + public UserResponse(String userId, List loginIds, String email, Boolean verifiedEmail, String phone, + Boolean verifiedPhone, String name, String givenName, String middleName, String familyName, + List roleNames, List userTenants, String status, String picture, Boolean test, + Long createdTime, Map customAttributes, Boolean totp, Boolean saml, + Map oauth, List ssoAppIds, String lockReason, Long tempLockExpiration) { + this.userId = userId; + this.loginIds = loginIds; + this.email = email; + this.verifiedEmail = verifiedEmail; + this.phone = phone; + this.verifiedPhone = verifiedPhone; + this.name = name; + this.givenName = givenName; + this.middleName = middleName; + this.familyName = familyName; + this.roleNames = roleNames; + this.userTenants = userTenants; + this.status = status; + this.picture = picture; + this.test = test; + this.createdTime = createdTime; + this.customAttributes = customAttributes; + this.TOTP = totp; + this.SAML = saml; + this.oAuth = oauth; + this.ssoAppIds = ssoAppIds; + this.lockReason = lockReason; + this.tempLockExpiration = tempLockExpiration; + } } diff --git a/src/main/java/com/descope/sdk/auth/OTPService.java b/src/main/java/com/descope/sdk/auth/OTPService.java index 6e6ad7e3..a88934b0 100644 --- a/src/main/java/com/descope/sdk/auth/OTPService.java +++ b/src/main/java/com/descope/sdk/auth/OTPService.java @@ -6,6 +6,8 @@ import com.descope.model.auth.UpdateOptions; import com.descope.model.magiclink.LoginOptions; import com.descope.model.magiclink.SignUpOptions; +import com.descope.model.otp.OTPSignInOptions; +import com.descope.model.otp.OTPSignUpOptions; import com.descope.model.user.User; import java.util.Map; @@ -37,6 +39,22 @@ String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginO String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginOptions, String refreshToken) throws DescopeException; + /** + * Use to login a user based on the given loginID either email or a phone and choose the selected + * delivery method for verification. + * + * @param deliveryMethod - {@link com.descope.enums.DeliveryMethod DeliveryMethod} + * @param loginId - User login ID + * @param loginOptions - {@link LoginOptions LoginOptions} + * @param refreshToken - if doing step-up or mfa refresh token is required + * @param signInOptions - {@link OTPSignInOptions OTPSignInOptions} optional provider, template, SSO app and + * recovery options + * @return - masked address where the code was sent (email or phone) + * @throws DescopeException - error upon failure + */ + String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginOptions, String refreshToken, + OTPSignInOptions signInOptions) throws DescopeException; + /** * Use to create a new user based on the given loginID either email or a phone. choose the * selected delivery method for verification. @@ -63,6 +81,21 @@ String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginO String signUp(DeliveryMethod deliveryMethod, String loginId, User user, SignUpOptions signupOptions) throws DescopeException; + /** + * Use to create a new user based on the given loginID either email or a phone. choose the + * selected delivery method for verification. + * + * @param deliveryMethod - {@link com.descope.enums.DeliveryMethod DeliveryMethod} + * @param loginId - User login ID + * @param user - {@link User User} + * @param signupOptions - optional claims, template, locale and tenant, sent as the login options + * @param otpSignUpOptions - {@link OTPSignUpOptions OTPSignUpOptions} optional provider and template + * @return masked address where the code was sent (email, whatsapp or phone) + * @throws DescopeException - error upon failure + */ + String signUp(DeliveryMethod deliveryMethod, String loginId, User user, SignUpOptions signupOptions, + OTPSignUpOptions otpSignUpOptions) throws DescopeException; + /** * Use to login in using loginID, if user does not exist, a new user will be created with the * given loginID. @@ -74,6 +107,21 @@ String signUp(DeliveryMethod deliveryMethod, String loginId, User user, SignUpOp */ String signUpOrIn(DeliveryMethod deliveryMethod, String loginId) throws DescopeException; + /** + * Use to login in using loginID, if user does not exist, a new user will be created with the + * given loginID. + * + * @param deliveryMethod - {@link com.descope.enums.DeliveryMethod DeliveryMethod} + * @param loginId - User login ID + * @param loginOptions - {@link LoginOptions LoginOptions} + * @param signInOptions - {@link OTPSignInOptions OTPSignInOptions} optional provider, template, SSO app and + * recovery options + * @return masked address where the code was sent (email, whatsapp or phone) + * @throws DescopeException - error upon failure + */ + String signUpOrIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginOptions, + OTPSignInOptions signInOptions) throws DescopeException; + /** * Use to verify a SignIn/SignUp based on the given loginID either an email or a phone followed by * the code used to verify and authenticate the user. diff --git a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java index e01b2b71..c08728a0 100644 --- a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java +++ b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java @@ -61,6 +61,7 @@ void verifyDeliveryMethod(DeliveryMethod deliveryMethod, String loginId, User us case SMS: case VOICE: case WHATSAPP: + case IM: String phone = user.getPhone(); if (StringUtils.isBlank(phone)) { phone = loginId; @@ -89,6 +90,7 @@ Class getMaskedValue(DeliveryMethod deliveryMethod) { case SMS: case VOICE: case WHATSAPP: + case IM: return MaskedPhoneRes.class; case EMAIL: return MaskedEmailRes.class; @@ -130,9 +132,27 @@ AuthenticationInfo getAuthenticationInfo(JWTResponse jwtResponse) { if (StringUtils.isNotBlank(jwtResponse.getRefreshJwt())) { refreshToken = validateAndCreateToken(jwtResponse.getRefreshJwt()); } - return new AuthenticationInfo( + AuthenticationInfo authenticationInfo = new AuthenticationInfo( sessionToken, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), jwtResponse.getIdpResponse()); + authenticationInfo.setCookieDomain(jwtResponse.getCookieDomain()); + authenticationInfo.setCookiePath(jwtResponse.getCookiePath()); + authenticationInfo.setCookieMaxAge(jwtResponse.getCookieMaxAge()); + authenticationInfo.setCookieExpiration(jwtResponse.getCookieExpiration()); + authenticationInfo.setSessionExpiration(jwtResponse.getSessionExpiration()); + authenticationInfo.setExternalToken(jwtResponse.getExternalToken()); + authenticationInfo.setClaims(jwtResponse.getClaims()); + authenticationInfo.setTenantSSOID(jwtResponse.getTenantSSOID()); + authenticationInfo.setTrustedDeviceJwt(jwtResponse.getTrustedDeviceJwt()); + authenticationInfo.setNextRefreshSeconds(jwtResponse.getNextRefreshSeconds()); + authenticationInfo.setCookieName(jwtResponse.getCookieName()); + authenticationInfo.setSessionCookieName(jwtResponse.getSessionCookieName()); + authenticationInfo.setSessionCookieDomain(jwtResponse.getSessionCookieDomain()); + authenticationInfo.setUnsavedSSO(jwtResponse.getUnsavedSSO()); + authenticationInfo.setKnownDeviceJwt(jwtResponse.getKnownDeviceJwt()); + authenticationInfo.setSsoAuthenticationOnly(jwtResponse.getSsoAuthenticationOnly()); + authenticationInfo.setUserCreationDeferred(jwtResponse.getUserCreationDeferred()); + return authenticationInfo; } @SuppressWarnings("unchecked") diff --git a/src/main/java/com/descope/sdk/auth/impl/MagicLinkServiceImpl.java b/src/main/java/com/descope/sdk/auth/impl/MagicLinkServiceImpl.java index a1464c9b..6effe624 100644 --- a/src/main/java/com/descope/sdk/auth/impl/MagicLinkServiceImpl.java +++ b/src/main/java/com/descope/sdk/auth/impl/MagicLinkServiceImpl.java @@ -51,6 +51,7 @@ public String signIn( if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } + rejectInstantMessage(deliveryMethod); ApiProxy apiProxy; Class maskedClass = getMaskedValue(deliveryMethod); @@ -80,6 +81,7 @@ public String signUp(DeliveryMethod deliveryMethod, String loginId, String uri, user = new User(); } + rejectInstantMessage(deliveryMethod); verifyDeliveryMethod(deliveryMethod, loginId, user); Class maskedClass = getMaskedValue(deliveryMethod); URI magicLinkSignUpURL = composeMagicLinkSignUpURI(deliveryMethod); @@ -114,6 +116,7 @@ public String signUpOrIn(DeliveryMethod deliveryMethod, String loginId, String u if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } + rejectInstantMessage(deliveryMethod); Class maskedClass = getMaskedValue(deliveryMethod); URI magicLinkSignUpOrInURL = composeMagicLinkSignUpOrInURI(deliveryMethod); @@ -208,6 +211,13 @@ public String updateUserPhone( return masked.getMasked(); } + // Magic links have no IM route + private static void rejectInstantMessage(DeliveryMethod deliveryMethod) { + if (deliveryMethod == DeliveryMethod.IM) { + throw ServerCommonException.invalidArgument("DeliveryMethod"); + } + } + private URI composeMagicLinkSignInURI(DeliveryMethod deliveryMethod) { return composeURI(SIGN_IN_MAGIC_LINK, deliveryMethod.getValue()); } diff --git a/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java b/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java index b1299b92..f23a5041 100644 --- a/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java +++ b/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java @@ -1,6 +1,7 @@ package com.descope.sdk.auth.impl; import static com.descope.enums.DeliveryMethod.EMAIL; +import static com.descope.enums.DeliveryMethod.IM; import static com.descope.enums.DeliveryMethod.SMS; import static com.descope.enums.DeliveryMethod.VOICE; import static com.descope.enums.DeliveryMethod.WHATSAPP; @@ -24,6 +25,8 @@ import com.descope.model.magiclink.SignUpOptions; import com.descope.model.magiclink.response.Masked; import com.descope.model.otp.AuthenticationVerifyRequestBody; +import com.descope.model.otp.OTPSignInOptions; +import com.descope.model.otp.OTPSignUpOptions; import com.descope.model.otp.SignInRequest; import com.descope.model.otp.SignUpRequest; import com.descope.model.otp.UpdateEmailRequestBody; @@ -50,13 +53,19 @@ public String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions @Override public String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginOptions, String refreshToken) throws DescopeException { + return signIn(deliveryMethod, loginId, loginOptions, refreshToken, null); + } + + @Override + public String signIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginOptions, String refreshToken, + OTPSignInOptions signInOptions) throws DescopeException { if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } ApiProxy apiProxy; Class maskedClass = getMaskedValue(deliveryMethod); URI otpSignInURL = composeSignInURL(deliveryMethod); - SignInRequest signInRequest = new SignInRequest(loginId, loginOptions); + SignInRequest signInRequest = newSignInRequest(loginId, loginOptions, signInOptions); if (JwtUtils.isJWTRequired(loginOptions)) { if (StringUtils.isBlank(refreshToken)) { throw ServerCommonException.invalidArgument("refreshToken"); @@ -77,6 +86,12 @@ public String signUp(DeliveryMethod deliveryMethod, String loginId, User user) { @Override public String signUp(DeliveryMethod deliveryMethod, String loginId, User user, SignUpOptions signUpOptions) throws DescopeException { + return signUp(deliveryMethod, loginId, user, signUpOptions, null); + } + + @Override + public String signUp(DeliveryMethod deliveryMethod, String loginId, User user, SignUpOptions signUpOptions, + OTPSignUpOptions otpSignUpOptions) throws DescopeException { if (user == null) { user = new User(); } @@ -87,6 +102,10 @@ public String signUp(DeliveryMethod deliveryMethod, String loginId, User user, S if (signUpOptions != null) { signUpRequest.setLoginOptions(signUpOptions); } + if (otpSignUpOptions != null) { + signUpRequest.setProviderId(otpSignUpOptions.getProviderId()); + signUpRequest.setTemplateId(otpSignUpOptions.getTemplateId()); + } Class maskedClass = getMaskedValue(deliveryMethod); URI otpSignUpURL = composeSignUpURI(deliveryMethod); ApiProxy apiProxy = getApiProxy(); @@ -96,14 +115,19 @@ public String signUp(DeliveryMethod deliveryMethod, String loginId, User user, S @Override public String signUpOrIn(DeliveryMethod deliveryMethod, String loginId) throws DescopeException { + return signUpOrIn(deliveryMethod, loginId, null, null); + } + @Override + public String signUpOrIn(DeliveryMethod deliveryMethod, String loginId, LoginOptions loginOptions, + OTPSignInOptions signInOptions) throws DescopeException { if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } Class maskedClass = getMaskedValue(deliveryMethod); URI otpSignUpOrInURL = composeSignUpOrInURL(deliveryMethod); - SignInRequest signInRequest = new SignInRequest(loginId, null); + SignInRequest signInRequest = newSignInRequest(loginId, loginOptions, signInOptions); ApiProxy apiProxy = getApiProxy(); Masked masked = apiProxy.post(otpSignUpOrInURL, signInRequest, maskedClass); return masked.getMasked(); @@ -165,6 +189,11 @@ public String updateUserEmail(String loginId, String email, String refreshToken, .addToLoginIds(updateOptions.isAddToLoginIds()) .onMergeUseExisting(updateOptions.isOnMergeUseExisting()) .templateOptions(templateOptions) + .providerId(updateOptions.getProviderId()) + .templateId(updateOptions.getTemplateId()) + .locale(updateOptions.getLocale()) + .failOnConflict(updateOptions.getFailOnConflict()) + .mfa(updateOptions.getMfa()) .build(); ApiProxy apiProxy = getApiProxy(refreshToken); Masked masked = apiProxy.post(otpUpdateUserEmail, updateEmailRequest, maskedClass); @@ -187,7 +216,7 @@ public String updateUserPhone(DeliveryMethod deliveryMethod, String loginId, Str throw ServerCommonException.invalidArgument("Phone"); } if (deliveryMethod != DeliveryMethod.WHATSAPP && deliveryMethod != DeliveryMethod.SMS - && deliveryMethod != DeliveryMethod.VOICE) { + && deliveryMethod != DeliveryMethod.VOICE && deliveryMethod != DeliveryMethod.IM) { throw ServerCommonException.invalidArgument("Method"); } if (StringUtils.isBlank(refreshToken)) { @@ -205,6 +234,11 @@ public String updateUserPhone(DeliveryMethod deliveryMethod, String loginId, Str .addToLoginIds(updateOptions.isAddToLoginIds()) .onMergeUseExisting(updateOptions.isOnMergeUseExisting()) .templateOptions(templateOptions) + .providerId(updateOptions.getProviderId()) + .templateId(updateOptions.getTemplateId()) + .locale(updateOptions.getLocale()) + .failOnConflict(updateOptions.getFailOnConflict()) + .mfa(updateOptions.getMfa()) .build(); ApiProxy apiProxy = getApiProxy(refreshToken); Masked masked = apiProxy.post(otpUpdateUserPhone, updatePhoneRequestBody, maskedClass); @@ -228,7 +262,7 @@ private URI composeSignUpOrInURL(DeliveryMethod deliveryMethod) { } private SignUpRequest newSignUpRequest(DeliveryMethod deliveryMethod, User user) { - if (SMS.equals(deliveryMethod) || VOICE.equals(deliveryMethod)) { + if (SMS.equals(deliveryMethod) || VOICE.equals(deliveryMethod) || IM.equals(deliveryMethod)) { return SignUpRequest.builder().phone(user.getPhone()).build(); } else if (WHATSAPP.equals(deliveryMethod)) { return SignUpRequest.builder().whatsApp(user.getPhone()).build(); @@ -237,6 +271,18 @@ private SignUpRequest newSignUpRequest(DeliveryMethod deliveryMethod, User user) } } + private static SignInRequest newSignInRequest(String loginId, LoginOptions loginOptions, + OTPSignInOptions signInOptions) { + SignInRequest signInRequest = new SignInRequest(loginId, loginOptions); + if (signInOptions != null) { + signInRequest.setProviderId(signInOptions.getProviderId()); + signInRequest.setTemplateId(signInOptions.getTemplateId()); + signInRequest.setSsoAppId(signInOptions.getSsoAppId()); + signInRequest.setUseRecovery(signInOptions.getUseRecovery()); + } + return signInRequest; + } + private URI composeSignUpURI(DeliveryMethod deliveryMethod) { return composeURI(SIGN_UP_OTP_LINK, deliveryMethod.getValue()); } diff --git a/src/main/java/com/descope/sdk/mgmt/impl/UserServiceImpl.java b/src/main/java/com/descope/sdk/mgmt/impl/UserServiceImpl.java index e60a2e5b..2eecf336 100644 --- a/src/main/java/com/descope/sdk/mgmt/impl/UserServiceImpl.java +++ b/src/main/java/com/descope/sdk/mgmt/impl/UserServiceImpl.java @@ -726,6 +726,9 @@ public OTPTestUserResponse generateOtpForTestUser(String loginId, DeliveryMethod if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } + if (deliveryMethod == DeliveryMethod.IM) { + throw ServerCommonException.invalidArgument("DeliveryMethod"); + } URI otpForTestUserUri = composeOTPForTestUserUri(); OTPTestUserRequest request = new OTPTestUserRequest(loginId, deliveryMethod.getValue()); ApiProxy apiProxy = getApiProxy(); @@ -738,6 +741,9 @@ public MagicLinkTestUserResponse generateMagicLinkForTestUser(String loginId, St if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } + if (deliveryMethod == DeliveryMethod.IM) { + throw ServerCommonException.invalidArgument("DeliveryMethod"); + } URI maginLinkForTestUserUri = composeMaginLinkForTestUserUri(); MagicLinkTestUserRequest request = new MagicLinkTestUserRequest(loginId, deliveryMethod.getValue(), uri); ApiProxy apiProxy = getApiProxy(); diff --git a/src/test/java/com/descope/sdk/auth/impl/MagicLinkServiceImplTest.java b/src/test/java/com/descope/sdk/auth/impl/MagicLinkServiceImplTest.java index e28739ce..6e6ec97d 100644 --- a/src/test/java/com/descope/sdk/auth/impl/MagicLinkServiceImplTest.java +++ b/src/test/java/com/descope/sdk/auth/impl/MagicLinkServiceImplTest.java @@ -50,6 +50,7 @@ import lombok.SneakyThrows; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.function.Executable; import org.junitpioneer.jupiter.RetryingTest; import org.mockito.MockedStatic; @@ -66,6 +67,17 @@ void setUp() { this.userService = ManagementServiceBuilder.buildServices(client).getUserService(); } + @Test + void testInstantMessageIsRejected() { + for (Executable call : Arrays.asList( + () -> magicLinkService.signIn(DeliveryMethod.IM, MOCK_PHONE, MOCK_URL, null, null), + () -> magicLinkService.signUp(DeliveryMethod.IM, MOCK_PHONE, MOCK_URL, new User()), + () -> magicLinkService.signUpOrIn(DeliveryMethod.IM, MOCK_PHONE, MOCK_URL))) { + ServerCommonException thrown = assertThrows(ServerCommonException.class, call); + assertEquals("The DeliveryMethod argument is invalid", thrown.getMessage()); + } + } + @Test void signUp() { User user = new User("someUserName", MOCK_EMAIL, "+910000000000"); diff --git a/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java b/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java index 3bbdc8d9..f8926d1b 100644 --- a/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java +++ b/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java @@ -19,19 +19,29 @@ import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.mockStatic; +import static org.mockito.Mockito.verify; import com.descope.enums.DeliveryMethod; import com.descope.exception.RateLimitExceededException; import com.descope.exception.ServerCommonException; +import com.descope.model.auth.AssociatedTenant; import com.descope.model.auth.AuthenticationInfo; +import com.descope.model.auth.IDPResponse; +import com.descope.model.auth.UpdateOptions; import com.descope.model.client.Client; import com.descope.model.jwt.Token; +import com.descope.model.jwt.response.JWTResponse; import com.descope.model.jwt.response.SigningKeysResponse; +import com.descope.model.magiclink.LoginOptions; +import com.descope.model.magiclink.SignUpOptions; import com.descope.model.magiclink.response.MaskedEmailRes; import com.descope.model.magiclink.response.MaskedPhoneRes; +import com.descope.model.otp.OTPSignInOptions; +import com.descope.model.otp.OTPSignUpOptions; import com.descope.model.user.User; import com.descope.model.user.request.UserRequest; import com.descope.model.user.response.OTPTestUserResponse; +import com.descope.model.user.response.UserFamily; import com.descope.model.user.response.UserResponse; import com.descope.proxy.ApiProxy; import com.descope.proxy.impl.ApiProxyBuilder; @@ -40,10 +50,18 @@ import com.descope.sdk.mgmt.UserService; import com.descope.sdk.mgmt.impl.ManagementServiceBuilder; import com.descope.utils.JwtUtils; +import com.fasterxml.jackson.annotation.JsonInclude.Include; +import com.fasterxml.jackson.databind.DeserializationFeature; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.net.URI; import java.util.Arrays; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Supplier; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junitpioneer.jupiter.RetryingTest; +import org.mockito.ArgumentCaptor; import org.mockito.MockedStatic; public class OTPServiceImplTest { @@ -238,6 +256,342 @@ void testVerifyCode() { assertThat(user.getLoginIds()).isNotEmpty(); } + /** Captures the Authorization header, URI and JSON body of the single request a call makes. */ + private static final class CapturedRequest { + String authorization; + String uri; + JsonNode body; + Class responseClass; + } + + @SuppressWarnings("unchecked") + private static CapturedRequest capture(Object response, Supplier call, AtomicReference result) { + CapturedRequest captured = new CapturedRequest(); + ApiProxy apiProxy = mock(ApiProxy.class); + doReturn(response).when(apiProxy).post(any(), any(), any()); + try (MockedStatic mockedApiProxyBuilder = mockStatic(ApiProxyBuilder.class); + MockedStatic mockedJwtUtils = mockStatic(JwtUtils.class)) { + mockedApiProxyBuilder.when(() -> ApiProxyBuilder.buildProxy(any(), any())).thenAnswer(inv -> { + captured.authorization = ((Supplier) inv.getArgument(0)).get(); + return apiProxy; + }); + mockedJwtUtils.when(() -> JwtUtils.isJWTRequired(any())).thenCallRealMethod(); + mockedJwtUtils.when(() -> JwtUtils.getToken(anyString(), any())).thenReturn(MOCK_TOKEN); + result.set(call.get()); + } + ArgumentCaptor uriCaptor = ArgumentCaptor.forClass(URI.class); + ArgumentCaptor bodyCaptor = ArgumentCaptor.forClass(Object.class); + ArgumentCaptor classCaptor = ArgumentCaptor.forClass(Class.class); + verify(apiProxy).post(uriCaptor.capture(), bodyCaptor.capture(), classCaptor.capture()); + captured.uri = uriCaptor.getValue().getPath(); + captured.body = new ObjectMapper().setSerializationInclusion(Include.NON_NULL).valueToTree(bodyCaptor.getValue()); + captured.responseClass = classCaptor.getValue(); + return captured; + } + + @Test + void testSignInWithSignInOptions() { + LoginOptions loginOptions = LoginOptions.builder() + .ssoAppId("sso-app").pkceChallenge("Y2hhbGxlbmdl").tenantId("tenant-1").build(); + OTPSignInOptions signInOptions = OTPSignInOptions.builder() + .providerId("provider-1").templateId("template-1").ssoAppId("sso-app").useRecovery(true).build(); + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedPhoneRes(MOCK_MASKED_PHONE), + () -> otpService.signIn(DeliveryMethod.IM, MOCK_PHONE, loginOptions, null, signInOptions), result); + + assertThat(result.get()).isEqualTo(MOCK_MASKED_PHONE); + assertThat(req.uri).isEqualTo("/v1/auth/otp/signin/im"); + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID); + assertThat(req.responseClass).isEqualTo(MaskedPhoneRes.class); + assertThat(req.body.get("loginId").asText()).isEqualTo(MOCK_PHONE); + assertThat(req.body.get("providerId").asText()).isEqualTo("provider-1"); + assertThat(req.body.get("templateId").asText()).isEqualTo("template-1"); + assertThat(req.body.get("ssoAppId").asText()).isEqualTo("sso-app"); + assertThat(req.body.get("useRecovery").asBoolean()).isTrue(); + JsonNode options = req.body.get("loginOptions"); + assertThat(options.get("ssoAppId").asText()).isEqualTo("sso-app"); + assertThat(options.get("pkceChallenge").asText()).isEqualTo("Y2hhbGxlbmdl"); + assertThat(options.get("tenantId").asText()).isEqualTo("tenant-1"); + } + + @Test + void testSignInWithoutSignInOptionsOmitsThem() { + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedEmailRes(MOCK_MASKED_EMAIL), + () -> otpService.signIn(DeliveryMethod.EMAIL, MOCK_EMAIL, null), result); + + assertThat(req.uri).isEqualTo("/v1/auth/otp/signin/email"); + assertThat(req.body.has("providerId")).isFalse(); + assertThat(req.body.has("templateId")).isFalse(); + assertThat(req.body.has("ssoAppId")).isFalse(); + assertThat(req.body.has("useRecovery")).isFalse(); + assertThat(req.body.has("loginOptions")).isFalse(); + } + + @Test + void testSignInWithSignInOptionsStepUpSendsRefreshToken() { + LoginOptions loginOptions = LoginOptions.builder().stepup(true).build(); + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedEmailRes(MOCK_MASKED_EMAIL), + () -> otpService.signIn(DeliveryMethod.EMAIL, MOCK_EMAIL, loginOptions, MOCK_REFRESH_TOKEN, + OTPSignInOptions.builder().useRecovery(true).build()), result); + + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID + ":" + MOCK_REFRESH_TOKEN); + } + + @Test + void testSignInWithSignInOptionsForEmptyLoginId() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> otpService.signIn(DeliveryMethod.IM, "", null, null, new OTPSignInOptions())); + assertEquals("The Login ID argument is invalid", thrown.getMessage()); + } + + @Test + void testSignInWithSignInOptionsStepUpWithoutRefreshToken() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> otpService.signIn(DeliveryMethod.SMS, MOCK_PHONE, LoginOptions.builder().mfa(true).build(), null, + new OTPSignInOptions())); + assertEquals("The refreshToken argument is invalid", thrown.getMessage()); + } + + @Test + void testSignUpOrInWithOptions() { + LoginOptions loginOptions = LoginOptions.builder().tenantId("tenant-1").templateId("login-template").build(); + OTPSignInOptions signInOptions = OTPSignInOptions.builder() + .providerId("provider-1").templateId("template-1").ssoAppId("sso-app").useRecovery(false).build(); + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedPhoneRes(MOCK_MASKED_PHONE), + () -> otpService.signUpOrIn(DeliveryMethod.WHATSAPP, MOCK_PHONE, loginOptions, signInOptions), result); + + assertThat(result.get()).isEqualTo(MOCK_MASKED_PHONE); + assertThat(req.uri).isEqualTo("/v1/auth/otp/signup-in/whatsapp"); + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID); + assertThat(req.responseClass).isEqualTo(MaskedPhoneRes.class); + assertThat(req.body.get("loginId").asText()).isEqualTo(MOCK_PHONE); + assertThat(req.body.get("providerId").asText()).isEqualTo("provider-1"); + assertThat(req.body.get("templateId").asText()).isEqualTo("template-1"); + assertThat(req.body.get("ssoAppId").asText()).isEqualTo("sso-app"); + assertThat(req.body.get("useRecovery").asBoolean()).isFalse(); + assertThat(req.body.get("loginOptions").get("tenantId").asText()).isEqualTo("tenant-1"); + assertThat(req.body.get("loginOptions").get("templateId").asText()).isEqualTo("login-template"); + } + + @Test + void testSignUpOrInWithOptionsForEmptyLoginId() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> otpService.signUpOrIn(DeliveryMethod.IM, "", null, null)); + assertEquals("The Login ID argument is invalid", thrown.getMessage()); + } + + @Test + void testSignUpWithOptions() { + User user = User.builder() + .loginId("login-1").name("Some Name").phone(MOCK_PHONE) + .recoveryEmail("recovery@domain.com").recoveryPhone("+1-5555555556").build(); + SignUpOptions signUpOptions = SignUpOptions.builder() + .locale("en").pkceChallenge("Y2hhbGxlbmdl").templateId("login-template").tenantId("tenant-1").build(); + OTPSignUpOptions otpSignUpOptions = OTPSignUpOptions.builder() + .providerId("provider-1").templateId("template-1").build(); + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedPhoneRes(MOCK_MASKED_PHONE), + () -> otpService.signUp(DeliveryMethod.IM, MOCK_PHONE, user, signUpOptions, otpSignUpOptions), result); + + assertThat(result.get()).isEqualTo(MOCK_MASKED_PHONE); + assertThat(req.uri).isEqualTo("/v1/auth/otp/signup/im"); + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID); + assertThat(req.responseClass).isEqualTo(MaskedPhoneRes.class); + assertThat(req.body.get("loginId").asText()).isEqualTo(MOCK_PHONE); + assertThat(req.body.get("phone").asText()).isEqualTo(MOCK_PHONE); + assertThat(req.body.has("whatsApp")).isFalse(); + assertThat(req.body.get("providerId").asText()).isEqualTo("provider-1"); + assertThat(req.body.get("templateId").asText()).isEqualTo("template-1"); + JsonNode userNode = req.body.get("user"); + assertThat(userNode.get("loginId").asText()).isEqualTo("login-1"); + assertThat(userNode.get("recoveryEmail").asText()).isEqualTo("recovery@domain.com"); + assertThat(userNode.get("recoveryPhone").asText()).isEqualTo("+1-5555555556"); + JsonNode options = req.body.get("loginOptions"); + assertThat(options.get("locale").asText()).isEqualTo("en"); + assertThat(options.get("pkceChallenge").asText()).isEqualTo("Y2hhbGxlbmdl"); + assertThat(options.get("templateId").asText()).isEqualTo("login-template"); + assertThat(options.get("tenantId").asText()).isEqualTo("tenant-1"); + } + + @Test + void testSignUpWithOptionsForEmptyLoginId() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> otpService.signUp(DeliveryMethod.IM, "", new User(), null, new OTPSignUpOptions())); + assertEquals("The Login ID argument is invalid", thrown.getMessage()); + } + + @Test + void testSignUpWithOptionsForInvalidPhone() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> otpService.signUp(DeliveryMethod.IM, "not-a-phone", new User(), null, new OTPSignUpOptions())); + assertEquals("The user.phone argument is invalid", thrown.getMessage()); + } + + private static UpdateOptions fullUpdateOptions() { + return UpdateOptions.builder() + .providerId("provider-1").templateId("template-1").locale("en").failOnConflict(true).mfa(true).build(); + } + + private static void assertUpdateOptions(JsonNode body) { + assertThat(body.get("providerId").asText()).isEqualTo("provider-1"); + assertThat(body.get("templateId").asText()).isEqualTo("template-1"); + assertThat(body.get("locale").asText()).isEqualTo("en"); + assertThat(body.get("failOnConflict").asBoolean()).isTrue(); + assertThat(body.get("mfa").asBoolean()).isTrue(); + } + + @Test + void testUpdateUserEmailWithUpdateOptions() { + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedEmailRes(MOCK_MASKED_EMAIL), + () -> otpService.updateUserEmail(MOCK_EMAIL, MOCK_EMAIL, MOCK_REFRESH_TOKEN, fullUpdateOptions()), result); + + assertThat(result.get()).isEqualTo(MOCK_MASKED_EMAIL); + assertThat(req.uri).isEqualTo("/v1/auth/otp/update/email"); + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID + ":" + MOCK_REFRESH_TOKEN); + assertThat(req.body.get("email").asText()).isEqualTo(MOCK_EMAIL); + assertUpdateOptions(req.body); + } + + @Test + void testUpdateUserEmailWithoutNewUpdateOptionsOmitsThem() { + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedEmailRes(MOCK_MASKED_EMAIL), + () -> otpService.updateUserEmail(MOCK_EMAIL, MOCK_EMAIL, MOCK_REFRESH_TOKEN, null), result); + + for (String field : Arrays.asList("providerId", "templateId", "locale", "failOnConflict", "mfa")) { + assertThat(req.body.has(field)).as(field).isFalse(); + } + } + + @Test + void testUpdateUserPhoneWithUpdateOptions() { + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(new MaskedPhoneRes(MOCK_MASKED_PHONE), + () -> otpService.updateUserPhone(DeliveryMethod.IM, MOCK_EMAIL, MOCK_PHONE, MOCK_REFRESH_TOKEN, + fullUpdateOptions()), result); + + assertThat(result.get()).isEqualTo(MOCK_MASKED_PHONE); + assertThat(req.uri).isEqualTo("/v1/auth/otp/update/phone/im"); + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID + ":" + MOCK_REFRESH_TOKEN); + assertThat(req.body.get("phone").asText()).isEqualTo(MOCK_PHONE); + assertUpdateOptions(req.body); + } + + @Test + void testVerifyCodeWithIMAndFullResponse() throws Exception { + String json = "{\"sessionJwt\":\"s\",\"refreshJwt\":\"r\",\"cookieDomain\":\"d\",\"cookiePath\":\"/\"," + + "\"cookieMaxAge\":1,\"cookieExpiration\":2,\"firstSeen\":true,\"sessionExpiration\":3," + + "\"externalToken\":\"ext\",\"claims\":{\"c\":\"v\"},\"tenantSSOID\":\"t-sso\"," + + "\"trustedDeviceJwt\":\"tdj\",\"nextRefreshSeconds\":4,\"cookieName\":\"cn\"," + + "\"sessionCookieName\":\"scn\",\"sessionCookieDomain\":\"scd\",\"unsavedSSO\":true," + + "\"knownDeviceJwt\":\"kdj\",\"ssoAuthenticationOnly\":true,\"userCreationDeferred\":true," + + "\"idpResponse\":{\"samlResponse\":\"sr\",\"samlGeneratedUser\":\"sgu\",\"samlGeneratedRoles\":\"sgr\"," + + "\"oidcResponse\":\"or\",\"oidcGeneratedUser\":\"ogu\",\"oidcGeneratedRoles\":\"ogr\"}," + + "\"user\":{\"userId\":\"u1\",\"TOTP\":true,\"SAML\":true,\"OAuth\":{\"google\":true}," + + "\"SCIM\":true,\"OIDC\":true,\"externalIds\":[\"x\"],\"webauthn\":true,\"password\":true," + + "\"editable\":true,\"push\":true,\"permissions\":[\"p\"],\"consentExpiration\":5," + + "\"recoveryEmail\":\"re\",\"verifiedRecoveryEmail\":true,\"recoveryPhone\":\"rp\"," + + "\"verifiedRecoveryPhone\":true,\"modifiedTime\":6,\"roleIds\":[\"r1\"],\"recoveryCodes\":true," + + "\"dependent\":true,\"scimTenantId\":\"st\",\"samlTenantId\":\"sat\",\"oidcTenantId\":\"ot\"," + + "\"consentTenantId\":\"ct\",\"lastLoginTime\":7,\"unknownField\":1," + + "\"userTenants\":[{\"tenantId\":\"t1\",\"permissions\":[\"tp\"],\"roleIds\":[\"tr\"]}]," + + "\"userFamilies\":[{\"familyId\":\"f1\",\"roleNames\":[\"fr\"],\"permissions\":[\"fp\"]," + + "\"familyScopedAttributes\":{\"a\":\"b\"}}]}}"; + JWTResponse jwtResponse = new ObjectMapper() + .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false).readValue(json, JWTResponse.class); + AtomicReference result = new AtomicReference<>(); + CapturedRequest req = capture(jwtResponse, + () -> otpService.verifyCode(DeliveryMethod.IM, MOCK_PHONE, "123456"), result); + + assertThat(req.uri).isEqualTo("/v1/auth/otp/verify/im"); + assertThat(req.authorization).isEqualTo("Bearer " + PROJECT_ID); + assertThat(req.body.get("loginId").asText()).isEqualTo(MOCK_PHONE); + assertThat(req.body.get("code").asText()).isEqualTo("123456"); + + AuthenticationInfo info = result.get(); + assertThat(info.getCookieDomain()).isEqualTo("d"); + assertThat(info.getCookiePath()).isEqualTo("/"); + assertThat(info.getCookieMaxAge()).isEqualTo(1); + assertThat(info.getCookieExpiration()).isEqualTo(2); + assertThat(info.getSessionExpiration()).isEqualTo(3); + assertThat(info.getExternalToken()).isEqualTo("ext"); + assertThat(info.getClaims()).containsEntry("c", "v"); + assertThat(info.getTenantSSOID()).isEqualTo("t-sso"); + assertThat(info.getTrustedDeviceJwt()).isEqualTo("tdj"); + assertThat(info.getNextRefreshSeconds()).isEqualTo(4); + assertThat(info.getCookieName()).isEqualTo("cn"); + assertThat(info.getSessionCookieName()).isEqualTo("scn"); + assertThat(info.getSessionCookieDomain()).isEqualTo("scd"); + assertThat(info.getUnsavedSSO()).isTrue(); + assertThat(info.getKnownDeviceJwt()).isEqualTo("kdj"); + assertThat(info.getSsoAuthenticationOnly()).isTrue(); + assertThat(info.getUserCreationDeferred()).isTrue(); + + IDPResponse idp = info.getIdpResponse(); + assertThat(idp.getSamlResponse()).isEqualTo("sr"); + assertThat(idp.getSamlGeneratedUser()).isEqualTo("sgu"); + assertThat(idp.getSamlGeneratedRoles()).isEqualTo("sgr"); + assertThat(idp.getOidcResponse()).isEqualTo("or"); + assertThat(idp.getOidcGeneratedUser()).isEqualTo("ogu"); + assertThat(idp.getOidcGeneratedRoles()).isEqualTo("ogr"); + + UserResponse user = info.getUser(); + assertThat(user.getTOTP()).isTrue(); + assertThat(user.getSAML()).isTrue(); + assertThat(user.getOAuth()).containsEntry("google", true); + assertThat(user.getScim()).isTrue(); + assertThat(user.getOidc()).isTrue(); + assertThat(user.getExternalIds()).containsExactly("x"); + assertThat(user.getWebauthn()).isTrue(); + assertThat(user.getPassword()).isTrue(); + assertThat(user.getEditable()).isTrue(); + assertThat(user.getPush()).isTrue(); + assertThat(user.getPermissions()).containsExactly("p"); + assertThat(user.getConsentExpiration()).isEqualTo(5L); + assertThat(user.getRecoveryEmail()).isEqualTo("re"); + assertThat(user.getVerifiedRecoveryEmail()).isTrue(); + assertThat(user.getRecoveryPhone()).isEqualTo("rp"); + assertThat(user.getVerifiedRecoveryPhone()).isTrue(); + assertThat(user.getModifiedTime()).isEqualTo(6L); + assertThat(user.getRoleIds()).containsExactly("r1"); + assertThat(user.getRecoveryCodes()).isTrue(); + assertThat(user.getDependent()).isTrue(); + assertThat(user.getScimTenantId()).isEqualTo("st"); + assertThat(user.getSamlTenantId()).isEqualTo("sat"); + assertThat(user.getOidcTenantId()).isEqualTo("ot"); + assertThat(user.getConsentTenantId()).isEqualTo("ct"); + assertThat(user.getLastLoginTime()).isEqualTo(7L); + AssociatedTenant tenant = user.getUserTenants().get(0); + assertThat(tenant.getPermissions()).containsExactly("tp"); + assertThat(tenant.getRoleIds()).containsExactly("tr"); + UserFamily family = user.getUserFamilies().get(0); + assertThat(family.getFamilyId()).isEqualTo("f1"); + assertThat(family.getRoleNames()).containsExactly("fr"); + assertThat(family.getPermissions()).containsExactly("fp"); + assertThat(family.getFamilyScopedAttributes()).containsEntry("a", "b"); + + // Response-only tenant fields are never sent back in requests + JsonNode tenantJson = new ObjectMapper().valueToTree(tenant); + assertThat(tenantJson.has("permissions")).isFalse(); + assertThat(tenantJson.has("roleIds")).isFalse(); + } + + @Test + void testUserResponseReadsLowercaseAuthMethodNames() throws Exception { + UserResponse user = new ObjectMapper().readValue( + "{\"totp\":true,\"saml\":true,\"oauth\":{\"google\":true},\"scim\":true,\"oidc\":true}", + UserResponse.class); + assertThat(user.getTOTP()).isTrue(); + assertThat(user.getSAML()).isTrue(); + assertThat(user.getOAuth()).containsEntry("google", true); + assertThat(user.getScim()).isTrue(); + assertThat(user.getOidc()).isTrue(); + } + @RetryingTest(value = 3, suspendForMs = 30000, onExceptions = RateLimitExceededException.class) void testFunctionalFullCycle() { String loginId = TestUtils.getRandomName("u-"); diff --git a/src/test/java/com/descope/sdk/mgmt/impl/UserServiceImplTest.java b/src/test/java/com/descope/sdk/mgmt/impl/UserServiceImplTest.java index 81f5f57d..f423a589 100644 --- a/src/test/java/com/descope/sdk/mgmt/impl/UserServiceImplTest.java +++ b/src/test/java/com/descope/sdk/mgmt/impl/UserServiceImplTest.java @@ -791,6 +791,16 @@ void testGenerateOtpForTestUserForEmptyLoginId() { assertEquals("The Login ID argument is invalid", thrown.getMessage()); } + @Test + void testGenerateForTestUserRejectsInstantMessage() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> userService.generateOtpForTestUser("someLoginId", DeliveryMethod.IM)); + assertEquals("The DeliveryMethod argument is invalid", thrown.getMessage()); + thrown = assertThrows(ServerCommonException.class, + () -> userService.generateMagicLinkForTestUser("someLoginId", mockUrl, DeliveryMethod.IM)); + assertEquals("The DeliveryMethod argument is invalid", thrown.getMessage()); + } + @Test void testGenerateOtpForTestUserForSuccess() { OTPTestUserResponse mockResponse = new OTPTestUserResponse("12345", "someLogin"); From 22caab100a3867adf8c1fa51c3daa075b7f4c47d Mon Sep 17 00:00:00 2001 From: Yosi Haran Date: Fri, 20 Nov 2026 01:32:10 +0200 Subject: [PATCH 2/2] fix: address review comments --- .../model/auth/AuthenticationInfo.java | 25 +++++++++++++++++++ .../model/user/response/UserResponse.java | 21 ++++++++++++---- .../java/com/descope/sdk/auth/OTPService.java | 2 +- .../sdk/auth/impl/AuthenticationsBase.java | 22 +--------------- .../descope/sdk/auth/impl/OTPServiceImpl.java | 4 +++ .../descope/sdk/mgmt/impl/JwtServiceImpl.java | 3 +-- .../sdk/auth/impl/OTPServiceImplTest.java | 8 ++++++ 7 files changed, 56 insertions(+), 29 deletions(-) diff --git a/src/main/java/com/descope/model/auth/AuthenticationInfo.java b/src/main/java/com/descope/model/auth/AuthenticationInfo.java index fd5bd4dd..c45748e3 100644 --- a/src/main/java/com/descope/model/auth/AuthenticationInfo.java +++ b/src/main/java/com/descope/model/auth/AuthenticationInfo.java @@ -1,6 +1,7 @@ package com.descope.model.auth; import com.descope.model.jwt.Token; +import com.descope.model.jwt.response.JWTResponse; import com.descope.model.user.response.UserResponse; import java.util.Map; import lombok.AllArgsConstructor; @@ -46,4 +47,28 @@ public AuthenticationInfo(Token token, Token refreshToken, UserResponse user, Bo this.firstSeen = firstSeen; this.idpResponse = idpResponse; } + + /** Builds the authentication info from a JWT response and its already validated tokens. */ + public static AuthenticationInfo from(JWTResponse jwtResponse, Token token, Token refreshToken) { + AuthenticationInfo authenticationInfo = new AuthenticationInfo( + token, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), jwtResponse.getIdpResponse()); + authenticationInfo.setCookieDomain(jwtResponse.getCookieDomain()); + authenticationInfo.setCookiePath(jwtResponse.getCookiePath()); + authenticationInfo.setCookieMaxAge(jwtResponse.getCookieMaxAge()); + authenticationInfo.setCookieExpiration(jwtResponse.getCookieExpiration()); + authenticationInfo.setSessionExpiration(jwtResponse.getSessionExpiration()); + authenticationInfo.setExternalToken(jwtResponse.getExternalToken()); + authenticationInfo.setClaims(jwtResponse.getClaims()); + authenticationInfo.setTenantSSOID(jwtResponse.getTenantSSOID()); + authenticationInfo.setTrustedDeviceJwt(jwtResponse.getTrustedDeviceJwt()); + authenticationInfo.setNextRefreshSeconds(jwtResponse.getNextRefreshSeconds()); + authenticationInfo.setCookieName(jwtResponse.getCookieName()); + authenticationInfo.setSessionCookieName(jwtResponse.getSessionCookieName()); + authenticationInfo.setSessionCookieDomain(jwtResponse.getSessionCookieDomain()); + authenticationInfo.setUnsavedSSO(jwtResponse.getUnsavedSSO()); + authenticationInfo.setKnownDeviceJwt(jwtResponse.getKnownDeviceJwt()); + authenticationInfo.setSsoAuthenticationOnly(jwtResponse.getSsoAuthenticationOnly()); + authenticationInfo.setUserCreationDeferred(jwtResponse.getUserCreationDeferred()); + return authenticationInfo; + } } diff --git a/src/main/java/com/descope/model/user/response/UserResponse.java b/src/main/java/com/descope/model/user/response/UserResponse.java index 6df815b1..4878d54c 100644 --- a/src/main/java/com/descope/model/user/response/UserResponse.java +++ b/src/main/java/com/descope/model/user/response/UserResponse.java @@ -8,7 +8,6 @@ import lombok.AllArgsConstructor; import lombok.Data; import lombok.NoArgsConstructor; -import lombok.Setter; @Data @NoArgsConstructor @@ -32,12 +31,8 @@ public class UserResponse { Boolean test; Long createdTime; Map customAttributes; - // Aliases accept the spec's names; the getters' lowercase names still work - @Setter(onMethod_ = {@JsonAlias({"TOTP"})}) Boolean TOTP; - @Setter(onMethod_ = {@JsonAlias({"SAML"})}) Boolean SAML; - @Setter(onMethod_ = {@JsonAlias({"OAuth"})}) Map oAuth; List ssoAppIds; /** Auth method that triggered brute-force protection, empty when none. */ @@ -110,4 +105,20 @@ public UserResponse(String userId, List loginIds, String email, Boolean this.lockReason = lockReason; this.tempLockExpiration = tempLockExpiration; } + + // Aliases accept the spec's names; the getters' lowercase names still work + @JsonAlias({"TOTP"}) + public void setTOTP(Boolean totp) { + this.TOTP = totp; + } + + @JsonAlias({"SAML"}) + public void setSAML(Boolean saml) { + this.SAML = saml; + } + + @JsonAlias({"OAuth"}) + public void setOAuth(Map oauth) { + this.oAuth = oauth; + } } diff --git a/src/main/java/com/descope/sdk/auth/OTPService.java b/src/main/java/com/descope/sdk/auth/OTPService.java index a88934b0..f6131634 100644 --- a/src/main/java/com/descope/sdk/auth/OTPService.java +++ b/src/main/java/com/descope/sdk/auth/OTPService.java @@ -113,7 +113,7 @@ String signUp(DeliveryMethod deliveryMethod, String loginId, User user, SignUpOp * * @param deliveryMethod - {@link com.descope.enums.DeliveryMethod DeliveryMethod} * @param loginId - User login ID - * @param loginOptions - {@link LoginOptions LoginOptions} + * @param loginOptions - {@link LoginOptions LoginOptions}, without step-up or MFA * @param signInOptions - {@link OTPSignInOptions OTPSignInOptions} optional provider, template, SSO app and * recovery options * @return masked address where the code was sent (email, whatsapp or phone) diff --git a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java index c08728a0..34c11268 100644 --- a/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java +++ b/src/main/java/com/descope/sdk/auth/impl/AuthenticationsBase.java @@ -132,27 +132,7 @@ AuthenticationInfo getAuthenticationInfo(JWTResponse jwtResponse) { if (StringUtils.isNotBlank(jwtResponse.getRefreshJwt())) { refreshToken = validateAndCreateToken(jwtResponse.getRefreshJwt()); } - AuthenticationInfo authenticationInfo = new AuthenticationInfo( - sessionToken, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), - jwtResponse.getIdpResponse()); - authenticationInfo.setCookieDomain(jwtResponse.getCookieDomain()); - authenticationInfo.setCookiePath(jwtResponse.getCookiePath()); - authenticationInfo.setCookieMaxAge(jwtResponse.getCookieMaxAge()); - authenticationInfo.setCookieExpiration(jwtResponse.getCookieExpiration()); - authenticationInfo.setSessionExpiration(jwtResponse.getSessionExpiration()); - authenticationInfo.setExternalToken(jwtResponse.getExternalToken()); - authenticationInfo.setClaims(jwtResponse.getClaims()); - authenticationInfo.setTenantSSOID(jwtResponse.getTenantSSOID()); - authenticationInfo.setTrustedDeviceJwt(jwtResponse.getTrustedDeviceJwt()); - authenticationInfo.setNextRefreshSeconds(jwtResponse.getNextRefreshSeconds()); - authenticationInfo.setCookieName(jwtResponse.getCookieName()); - authenticationInfo.setSessionCookieName(jwtResponse.getSessionCookieName()); - authenticationInfo.setSessionCookieDomain(jwtResponse.getSessionCookieDomain()); - authenticationInfo.setUnsavedSSO(jwtResponse.getUnsavedSSO()); - authenticationInfo.setKnownDeviceJwt(jwtResponse.getKnownDeviceJwt()); - authenticationInfo.setSsoAuthenticationOnly(jwtResponse.getSsoAuthenticationOnly()); - authenticationInfo.setUserCreationDeferred(jwtResponse.getUserCreationDeferred()); - return authenticationInfo; + return AuthenticationInfo.from(jwtResponse, sessionToken, refreshToken); } @SuppressWarnings("unchecked") diff --git a/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java b/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java index f23a5041..d309586d 100644 --- a/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java +++ b/src/main/java/com/descope/sdk/auth/impl/OTPServiceImpl.java @@ -124,6 +124,10 @@ public String signUpOrIn(DeliveryMethod deliveryMethod, String loginId, LoginOpt if (StringUtils.isBlank(loginId)) { throw ServerCommonException.invalidArgument("Login ID"); } + // Sign-up-or-in takes no refresh JWT for step-up or MFA + if (JwtUtils.isJWTRequired(loginOptions)) { + throw ServerCommonException.invalidArgument("loginOptions"); + } Class maskedClass = getMaskedValue(deliveryMethod); URI otpSignUpOrInURL = composeSignUpOrInURL(deliveryMethod); diff --git a/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java b/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java index f3665e8b..0f53213c 100644 --- a/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java +++ b/src/main/java/com/descope/sdk/mgmt/impl/JwtServiceImpl.java @@ -142,8 +142,7 @@ private AuthenticationInfo validateAndCreateAuthInfo(JWTResponse jwtResponse) th } Token sessionToken = validateAndCreateToken(jwtResponse.getSessionJwt()); Token refreshToken = validateAndCreateToken(jwtResponse.getRefreshJwt()); - return new AuthenticationInfo(sessionToken, refreshToken, jwtResponse.getUser(), jwtResponse.getFirstSeen(), - jwtResponse.getIdpResponse()); + return AuthenticationInfo.from(jwtResponse, sessionToken, refreshToken); } private URI composeUpdateJwtUri() { diff --git a/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java b/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java index f8926d1b..9d835a3d 100644 --- a/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java +++ b/src/test/java/com/descope/sdk/auth/impl/OTPServiceImplTest.java @@ -383,6 +383,14 @@ void testSignUpOrInWithOptionsForEmptyLoginId() { assertEquals("The Login ID argument is invalid", thrown.getMessage()); } + @Test + void testSignUpOrInWithOptionsRejectsStepUp() { + ServerCommonException thrown = assertThrows(ServerCommonException.class, + () -> otpService.signUpOrIn(DeliveryMethod.SMS, MOCK_PHONE, LoginOptions.builder().stepup(true).build(), + null)); + assertEquals("The loginOptions argument is invalid", thrown.getMessage()); + } + @Test void testSignUpWithOptions() { User user = User.builder()